﻿#region Using directives

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Configuration.Provider;
using System.Web.Configuration;
using System.Web;
using NetROS.Tiers.Entities;
using NetROS.Tiers.Data;
using NetROS.Tiers.Data.Bases;

#endregion

namespace NetROS.Tiers.Data
{
	/// <summary>
	/// This class represents the Data source repository and gives access to all the underlying providers.
	/// </summary>
	[CLSCompliant(true)]
	public sealed class DataRepository 
	{
		private static volatile NetTiersProvider _provider = null;
        private static volatile NetTiersProviderCollection _providers = null;
		private static volatile NetTiersServiceSection _section = null;
        
        private static object SyncRoot = new object();
				
		private DataRepository()
		{
		}
		
		#region Public LoadProvider
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        public static void LoadProvider(NetTiersProvider provider)
        {
			LoadProvider(provider, false);
        }
		
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        /// <param name="setAsDefault">ability to set any valid provider as the default provider for the DataRepository.</param>
		public static void LoadProvider(NetTiersProvider provider, bool setAsDefault)
        {
            if (provider == null)
                throw new ArgumentNullException("provider");

            if (_providers == null)
			{
				lock(SyncRoot)
				{
            		if (_providers == null)
						_providers = new NetTiersProviderCollection();
				}
			}
			
            if (_providers[provider.Name] == null)
            {
                lock (_providers.SyncRoot)
                {
                    _providers.Add(provider);
                }
            }

            if (_provider == null || setAsDefault)
            {
                lock (SyncRoot)
                {
                    if(_provider == null || setAsDefault)
                         _provider = provider;
                }
            }
        }
		#endregion 
		
		///<summary>
		/// Configuration based provider loading, will load the providers on first call.
		///</summary>
		private static void LoadProviders()
        {
            // Avoid claiming lock if providers are already loaded
            if (_provider == null)
            {
                lock (SyncRoot)
                {
                    // Do this again to make sure _provider is still null
                    if (_provider == null)
                    {
                        // Load registered providers and point _provider to the default provider
                        _providers = new NetTiersProviderCollection();

                        ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
						_provider = _providers[NetTiersSection.DefaultProvider];

                        if (_provider == null)
                        {
                            throw new ProviderException("Unable to load default NetTiersProvider");
                        }
                    }
                }
            }
        }

		/// <summary>
        /// Gets the provider.
        /// </summary>
        /// <value>The provider.</value>
        public static NetTiersProvider Provider
        {
            get { LoadProviders(); return _provider; }
        }

		/// <summary>
        /// Gets the provider collection.
        /// </summary>
        /// <value>The providers.</value>
        public static NetTiersProviderCollection Providers
        {
            get { LoadProviders(); return _providers; }
        }
		
		/// <summary>
		/// Creates a new <c cref="TransactionManager"/> instance from the current datasource.
		/// </summary>
		/// <returns></returns>
		public TransactionManager CreateTransaction()
		{
			return _provider.CreateTransaction();
		}

		#region Configuration

		/// <summary>
		/// Gets a reference to the configured NetTiersServiceSection object.
		/// </summary>
		public static NetTiersServiceSection NetTiersSection
		{
			get
			{
				// Try to get a reference to the default <netTiersService> section
				_section = WebConfigurationManager.GetSection("netTiersService") as NetTiersServiceSection;

				if ( _section == null )
				{
					// otherwise look for section based on the assembly name
					_section = WebConfigurationManager.GetSection("NetROS.Tiers.Data") as NetTiersServiceSection;
				}

				if ( _section == null )
				{
					throw new ProviderException("Unable to load NetTiersServiceSection");
				}

				return _section;
			}
		}

		#endregion Configuration

		#region Connections

		/// <summary>
		/// Gets a reference to the ConnectionStringSettings collection.
		/// </summary>
		public static ConnectionStringSettingsCollection ConnectionStrings
		{
			get
			{
				return WebConfigurationManager.ConnectionStrings;
			}
		}

		// dictionary of connection providers
		private static Dictionary<String, ConnectionProvider> _connections;

		/// <summary>
		/// Gets the dictionary of connection providers.
		/// </summary>
		public static Dictionary<String, ConnectionProvider> Connections
		{
			get
			{
				if ( _connections == null )
				{
					lock (SyncRoot)
                	{
						if (_connections == null)
						{
							_connections = new Dictionary<String, ConnectionProvider>();
		
							// add a connection provider for each configured connection string
							foreach ( ConnectionStringSettings conn in ConnectionStrings )
							{
								_connections.Add(conn.Name, new ConnectionProvider(conn.Name));
							}
						}
					}
				}

				return _connections;
			}
		}

		/// <summary>
		/// Adds the specified connection string to the map of connection strings.
		/// </summary>
		/// <param name="connectionStringName">The connection string name.</param>
		/// <param name="connectionString">The provider specific connection information.</param>
		public static void AddConnection(String connectionStringName, String connectionString)
		{
			lock (SyncRoot)
            {
				Connections.Remove(connectionStringName);
				ConnectionProvider connection = new ConnectionProvider(connectionStringName, connectionString);
				Connections.Add(connectionStringName, connection);
			}
		}

		/// <summary>
		/// Provides ability to switch connection string at runtime.
		/// </summary>
		public sealed class ConnectionProvider
		{
			private NetTiersProvider _provider;
			private NetTiersProviderCollection _providers;
			private String _connectionStringName;
			private String _connectionString;

			/// <summary>
			/// Initializes a new instance of the ConnectionProvider class.
			/// </summary>
			/// <param name="connectionStringName">The connection string name.</param>
			public ConnectionProvider(String connectionStringName)
			{
				_connectionStringName = connectionStringName;
			}

			/// <summary>
			/// Initializes a new instance of the ConnectionProvider class.
			/// </summary>
			/// <param name="connectionStringName">The connection string name.</param>
			/// <param name="connectionString">The provider specific connection information.</param>
			public ConnectionProvider(String connectionStringName, String connectionString)
			{
				_connectionString = connectionString;
				_connectionStringName = connectionStringName;
			}

			/// <summary>
			/// Gets the provider.
			/// </summary>
			public NetTiersProvider Provider
			{
				get { LoadProviders(); return _provider; }
			}

			/// <summary>
			/// Gets the provider collection.
			/// </summary>
			public NetTiersProviderCollection Providers
			{
				get { LoadProviders(); return _providers; }
			}

			/// <summary>
			/// Instantiates the configured providers based on the supplied connection string.
			/// </summary>
			private void LoadProviders()
			{
				DataRepository.LoadProviders();

				// Avoid claiming lock if providers are already loaded
				if ( _providers == null )
				{
					lock ( SyncRoot )
					{
						// Do this again to make sure _provider is still null
						if ( _providers == null )
						{
							// apply connection information to each provider
							for ( int i = 0; i < NetTiersSection.Providers.Count; i++ )
							{
								NetTiersSection.Providers[i].Parameters["connectionStringName"] = _connectionStringName;
								// remove previous connection string, if any
								NetTiersSection.Providers[i].Parameters.Remove("connectionString");

								if ( !String.IsNullOrEmpty(_connectionString) )
								{
									NetTiersSection.Providers[i].Parameters["connectionString"] = _connectionString;
								}
							}

							// Load registered providers and point _provider to the default provider
							_providers = new NetTiersProviderCollection();

							ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
							_provider = _providers[NetTiersSection.DefaultProvider];
						}
					}
				}
			}
		}

		#endregion Connections

		#region Static properties
		
		#region OsobaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Osoba"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OsobaProviderBase OsobaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OsobaProvider;
			}
		}
		
		#endregion
		
		#region OsobaBankovniRacunProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OsobaBankovniRacun"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OsobaBankovniRacunProviderBase OsobaBankovniRacunProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OsobaBankovniRacunProvider;
			}
		}
		
		#endregion
		
		#region OsobaPlacaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OsobaPlaca"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OsobaPlacaProviderBase OsobaPlacaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OsobaPlacaProvider;
			}
		}
		
		#endregion
		
		#region OsobaOrganizacijskaJedinicaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OsobaOrganizacijskaJedinica"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OsobaOrganizacijskaJedinicaProviderBase OsobaOrganizacijskaJedinicaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OsobaOrganizacijskaJedinicaProvider;
			}
		}
		
		#endregion
		
		#region OsobaObustavaNaknadaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OsobaObustavaNaknada"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OsobaObustavaNaknadaProviderBase OsobaObustavaNaknadaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OsobaObustavaNaknadaProvider;
			}
		}
		
		#endregion
		
		#region OsobaPoreznaOlaksicaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OsobaPoreznaOlaksica"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OsobaPoreznaOlaksicaProviderBase OsobaPoreznaOlaksicaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OsobaPoreznaOlaksicaProvider;
			}
		}
		
		#endregion
		
		#region OsobaAdreseProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OsobaAdrese"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OsobaAdreseProviderBase OsobaAdreseProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OsobaAdreseProvider;
			}
		}
		
		#endregion
		
		#region _PostavkeRobnogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="_PostavkeRobnog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static _PostavkeRobnogProviderBase _PostavkeRobnogProvider
		{
			get 
			{
				LoadProviders();
				return _provider._PostavkeRobnogProvider;
			}
		}
		
		#endregion
		
		#region OsobaRadniOdnosProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OsobaRadniOdnos"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OsobaRadniOdnosProviderBase OsobaRadniOdnosProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OsobaRadniOdnosProvider;
			}
		}
		
		#endregion
		
		#region OsobaRadnoMjestoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OsobaRadnoMjesto"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OsobaRadnoMjestoProviderBase OsobaRadnoMjestoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OsobaRadnoMjestoProvider;
			}
		}
		
		#endregion
		
		#region PrilagodenDokumentTipProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PrilagodenDokumentTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PrilagodenDokumentTipProviderBase PrilagodenDokumentTipProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PrilagodenDokumentTipProvider;
			}
		}
		
		#endregion
		
		#region PorezProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Porez"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PorezProviderBase PorezProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PorezProvider;
			}
		}
		
		#endregion
		
		#region ParametriNaziviProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ParametriNazivi"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ParametriNaziviProviderBase ParametriNaziviProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ParametriNaziviProvider;
			}
		}
		
		#endregion
		
		#region ParametriProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Parametri"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ParametriProviderBase ParametriProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ParametriProvider;
			}
		}
		
		#endregion
		
		#region OSTipRetkaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OSTipRetka"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OSTipRetkaProviderBase OSTipRetkaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OSTipRetkaProvider;
			}
		}
		
		#endregion
		
		#region PrimanjeTipProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PrimanjeTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PrimanjeTipProviderBase PrimanjeTipProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PrimanjeTipProvider;
			}
		}
		
		#endregion
		
		#region OsnovnoSredstvoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OsnovnoSredstvo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OsnovnoSredstvoProviderBase OsnovnoSredstvoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OsnovnoSredstvoProvider;
			}
		}
		
		#endregion
		
		#region OrganizacijaTipProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OrganizacijaTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OrganizacijaTipProviderBase OrganizacijaTipProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OrganizacijaTipProvider;
			}
		}
		
		#endregion
		
		#region OrganizacijaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Organizacija"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OrganizacijaProviderBase OrganizacijaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OrganizacijaProvider;
			}
		}
		
		#endregion
		
		#region VrstaFinDokumentaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VrstaFinDokumenta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VrstaFinDokumentaProviderBase VrstaFinDokumentaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VrstaFinDokumentaProvider;
			}
		}
		
		#endregion
		
		#region OrganizacijaZiroRacunProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OrganizacijaZiroRacun"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OrganizacijaZiroRacunProviderBase OrganizacijaZiroRacunProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OrganizacijaZiroRacunProvider;
			}
		}
		
		#endregion
		
		#region TipKontaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TipKonta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TipKontaProviderBase TipKontaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TipKontaProvider;
			}
		}
		
		#endregion
		
		#region ObustavaNaknadaTipProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ObustavaNaknadaTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ObustavaNaknadaTipProviderBase ObustavaNaknadaTipProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ObustavaNaknadaTipProvider;
			}
		}
		
		#endregion
		
		#region OrganizacijskaJedinicaTipProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OrganizacijskaJedinicaTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OrganizacijskaJedinicaTipProviderBase OrganizacijskaJedinicaTipProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OrganizacijskaJedinicaTipProvider;
			}
		}
		
		#endregion
		
		#region OSKarticaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OSKartica"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OSKarticaProviderBase OSKarticaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OSKarticaProvider;
			}
		}
		
		#endregion
		
		#region OrganizacijskaJedinicaZiroRacunProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OrganizacijskaJedinicaZiroRacun"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OrganizacijskaJedinicaZiroRacunProviderBase OrganizacijskaJedinicaZiroRacunProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OrganizacijskaJedinicaZiroRacunProvider;
			}
		}
		
		#endregion
		
		#region OSGrupaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OSGrupa"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OSGrupaProviderBase OSGrupaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OSGrupaProvider;
			}
		}
		
		#endregion
		
		#region OsnovaOsiguranjaTipProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OsnovaOsiguranjaTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OsnovaOsiguranjaTipProviderBase OsnovaOsiguranjaTipProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OsnovaOsiguranjaTipProvider;
			}
		}
		
		#endregion
		
		#region OrganizacijskaJedinicaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OrganizacijskaJedinica"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OrganizacijskaJedinicaProviderBase OrganizacijskaJedinicaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OrganizacijskaJedinicaProvider;
			}
		}
		
		#endregion
		
		#region OSAmortizacijskaGrupaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OSAmortizacijskaGrupa"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OSAmortizacijskaGrupaProviderBase OSAmortizacijskaGrupaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OSAmortizacijskaGrupaProvider;
			}
		}
		
		#endregion
		
		#region OSAGPromjenaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OSAGPromjena"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OSAGPromjenaProviderBase OSAGPromjenaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OSAGPromjenaProvider;
			}
		}
		
		#endregion
		
		#region PutniNalogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PutniNalog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PutniNalogProviderBase PutniNalogProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PutniNalogProvider;
			}
		}
		
		#endregion
		
		#region PutniNalogAkontacijaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PutniNalogAkontacija"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PutniNalogAkontacijaProviderBase PutniNalogAkontacijaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PutniNalogAkontacijaProvider;
			}
		}
		
		#endregion
		
		#region ValutaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Valuta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ValutaProviderBase ValutaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ValutaProvider;
			}
		}
		
		#endregion
		
		#region PutniNalogStavkaDnevnicaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PutniNalogStavkaDnevnica"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PutniNalogStavkaDnevnicaProviderBase PutniNalogStavkaDnevnicaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PutniNalogStavkaDnevnicaProvider;
			}
		}
		
		#endregion
		
		#region ReportProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Report"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ReportProviderBase ReportProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ReportProvider;
			}
		}
		
		#endregion
		
		#region SklDZahtijevStavkeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SklDZahtijevStavke"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SklDZahtijevStavkeProviderBase SklDZahtijevStavkeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SklDZahtijevStavkeProvider;
			}
		}
		
		#endregion
		
		#region SklDLagerProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SklDLager"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SklDLagerProviderBase SklDLagerProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SklDLagerProvider;
			}
		}
		
		#endregion
		
		#region SifarnikTipProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SifarnikTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SifarnikTipProviderBase SifarnikTipProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SifarnikTipProvider;
			}
		}
		
		#endregion
		
		#region SklDZahtjevGlavaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SklDZahtjevGlava"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SklDZahtjevGlavaProviderBase SklDZahtjevGlavaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SklDZahtjevGlavaProvider;
			}
		}
		
		#endregion
		
		#region SifarnikProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Sifarnik"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SifarnikProviderBase SifarnikProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SifarnikProvider;
			}
		}
		
		#endregion
		
		#region TecajValuteProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TecajValute"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TecajValuteProviderBase TecajValuteProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TecajValuteProvider;
			}
		}
		
		#endregion
		
		#region VrstaRaspodjeleProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VrstaRaspodjele"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VrstaRaspodjeleProviderBase VrstaRaspodjeleProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VrstaRaspodjeleProvider;
			}
		}
		
		#endregion
		
		#region VoziloProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Vozilo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VoziloProviderBase VoziloProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VoziloProvider;
			}
		}
		
		#endregion
		
		#region VirmanProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Virman"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VirmanProviderBase VirmanProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VirmanProvider;
			}
		}
		
		#endregion
		
		#region VezaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Veza"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VezaProviderBase VezaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VezaProvider;
			}
		}
		
		#endregion
		
		#region TipIspisaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TipIspisa"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TipIspisaProviderBase TipIspisaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TipIspisaProvider;
			}
		}
		
		#endregion
		
		#region ShemaKnjizenjeNazivKolonaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ShemaKnjizenjeNazivKolona"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ShemaKnjizenjeNazivKolonaProviderBase ShemaKnjizenjeNazivKolonaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ShemaKnjizenjeNazivKolonaProvider;
			}
		}
		
		#endregion
		
		#region ShemaKnjizenjaRobnoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ShemaKnjizenjaRobno"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ShemaKnjizenjaRobnoProviderBase ShemaKnjizenjaRobnoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ShemaKnjizenjaRobnoProvider;
			}
		}
		
		#endregion
		
		#region ReportPivotsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ReportPivots"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ReportPivotsProviderBase ReportPivotsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ReportPivotsProvider;
			}
		}
		
		#endregion
		
		#region RadniNalogVezaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="RadniNalogVeza"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static RadniNalogVezaProviderBase RadniNalogVezaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.RadniNalogVezaProvider;
			}
		}
		
		#endregion
		
		#region RabatProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Rabat"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static RabatProviderBase RabatProvider
		{
			get 
			{
				LoadProviders();
				return _provider.RabatProvider;
			}
		}
		
		#endregion
		
		#region PutniNalogStavkaOstaloProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PutniNalogStavkaOstalo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PutniNalogStavkaOstaloProviderBase PutniNalogStavkaOstaloProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PutniNalogStavkaOstaloProvider;
			}
		}
		
		#endregion
		
		#region PutniNalogStavkaPrijevozProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PutniNalogStavkaPrijevoz"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PutniNalogStavkaPrijevozProviderBase PutniNalogStavkaPrijevozProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PutniNalogStavkaPrijevozProvider;
			}
		}
		
		#endregion
		
		#region RadniOdnosTipProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="RadniOdnosTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static RadniOdnosTipProviderBase RadniOdnosTipProvider
		{
			get 
			{
				LoadProviders();
				return _provider.RadniOdnosTipProvider;
			}
		}
		
		#endregion
		
		#region RabatSpecProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="RabatSpec"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static RabatSpecProviderBase RabatSpecProvider
		{
			get 
			{
				LoadProviders();
				return _provider.RabatSpecProvider;
			}
		}
		
		#endregion
		
		#region RadnoMjestoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="RadnoMjesto"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static RadnoMjestoProviderBase RadnoMjestoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.RadnoMjestoProvider;
			}
		}
		
		#endregion
		
		#region ReportKolumnaTipProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ReportKolumnaTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ReportKolumnaTipProviderBase ReportKolumnaTipProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ReportKolumnaTipProvider;
			}
		}
		
		#endregion
		
		#region ReportKolumnaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ReportKolumna"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ReportKolumnaProviderBase ReportKolumnaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ReportKolumnaProvider;
			}
		}
		
		#endregion
		
		#region ReportiServerProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ReportiServer"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ReportiServerProviderBase ReportiServerProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ReportiServerProvider;
			}
		}
		
		#endregion
		
		#region RazdobljeStopaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="RazdobljeStopa"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static RazdobljeStopaProviderBase RazdobljeStopaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.RazdobljeStopaProvider;
			}
		}
		
		#endregion
		
		#region RazdobljeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Razdoblje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static RazdobljeProviderBase RazdobljeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.RazdobljeProvider;
			}
		}
		
		#endregion
		
		#region ObracunVirmanProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ObracunVirman"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ObracunVirmanProviderBase ObracunVirmanProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ObracunVirmanProvider;
			}
		}
		
		#endregion
		
		#region ObracunRSMProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ObracunRSM"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ObracunRSMProviderBase ObracunRSMProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ObracunRSMProvider;
			}
		}
		
		#endregion
		
		#region DokumentProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Dokument"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DokumentProviderBase DokumentProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DokumentProvider;
			}
		}
		
		#endregion
		
		#region DokumentPlacanjeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DokumentPlacanje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DokumentPlacanjeProviderBase DokumentPlacanjeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DokumentPlacanjeProvider;
			}
		}
		
		#endregion
		
		#region ObracunOsobaPrimanjeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ObracunOsobaPrimanje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ObracunOsobaPrimanjeProviderBase ObracunOsobaPrimanjeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ObracunOsobaPrimanjeProvider;
			}
		}
		
		#endregion
		
		#region DokumentTipProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DokumentTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DokumentTipProviderBase DokumentTipProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DokumentTipProvider;
			}
		}
		
		#endregion
		
		#region DjelatnikProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Djelatnik"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DjelatnikProviderBase DjelatnikProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DjelatnikProvider;
			}
		}
		
		#endregion
		
		#region DokumentDodatakProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DokumentDodatak"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DokumentDodatakProviderBase DokumentDodatakProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DokumentDodatakProvider;
			}
		}
		
		#endregion
		
		#region DokumentStavkaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DokumentStavka"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DokumentStavkaProviderBase DokumentStavkaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DokumentStavkaProvider;
			}
		}
		
		#endregion
		
		#region DnevnicaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Dnevnica"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DnevnicaProviderBase DnevnicaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DnevnicaProvider;
			}
		}
		
		#endregion
		
		#region DjelatnikInGrupaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DjelatnikInGrupa"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DjelatnikInGrupaProviderBase DjelatnikInGrupaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DjelatnikInGrupaProvider;
			}
		}
		
		#endregion
		
		#region DokumentStavkaOpisProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DokumentStavkaOpis"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DokumentStavkaOpisProviderBase DokumentStavkaOpisProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DokumentStavkaOpisProvider;
			}
		}
		
		#endregion
		
		#region DokumentZaglavljeSpecTipProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DokumentZaglavljeSpecTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DokumentZaglavljeSpecTipProviderBase DokumentZaglavljeSpecTipProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DokumentZaglavljeSpecTipProvider;
			}
		}
		
		#endregion
		
		#region DokumentZaglavljeSpecPostavkeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DokumentZaglavljeSpecPostavke"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DokumentZaglavljeSpecPostavkeProviderBase DokumentZaglavljeSpecPostavkeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DokumentZaglavljeSpecPostavkeProvider;
			}
		}
		
		#endregion
		
		#region GrupaParametraProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GrupaParametra"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GrupaParametraProviderBase GrupaParametraProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GrupaParametraProvider;
			}
		}
		
		#endregion
		
		#region DokumentZaglavljeSpecDokTipProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DokumentZaglavljeSpecDokTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DokumentZaglavljeSpecDokTipProviderBase DokumentZaglavljeSpecDokTipProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DokumentZaglavljeSpecDokTipProvider;
			}
		}
		
		#endregion
		
		#region DokumentZaglavljeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DokumentZaglavlje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DokumentZaglavljeProviderBase DokumentZaglavljeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DokumentZaglavljeProvider;
			}
		}
		
		#endregion
		
		#region DefParametraProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DefParametra"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DefParametraProviderBase DefParametraProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DefParametraProvider;
			}
		}
		
		#endregion
		
		#region BlagdanProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Blagdan"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static BlagdanProviderBase BlagdanProvider
		{
			get 
			{
				LoadProviders();
				return _provider.BlagdanProvider;
			}
		}
		
		#endregion
		
		#region ArtiklMjeraProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ArtiklMjera"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ArtiklMjeraProviderBase ArtiklMjeraProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ArtiklMjeraProvider;
			}
		}
		
		#endregion
		
		#region ArtiklKategorijaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ArtiklKategorija"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ArtiklKategorijaProviderBase ArtiklKategorijaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ArtiklKategorijaProvider;
			}
		}
		
		#endregion
		
		#region ArtiklProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Artikl"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ArtiklProviderBase ArtiklProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ArtiklProvider;
			}
		}
		
		#endregion
		
		#region AdresaTipProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="AdresaTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AdresaTipProviderBase AdresaTipProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AdresaTipProvider;
			}
		}
		
		#endregion
		
		#region _PostavkeServeraProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="_PostavkeServera"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static _PostavkeServeraProviderBase _PostavkeServeraProvider
		{
			get 
			{
				LoadProviders();
				return _provider._PostavkeServeraProvider;
			}
		}
		
		#endregion
		
		#region ArtiklSpecifikacijaTipProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ArtiklSpecifikacijaTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ArtiklSpecifikacijaTipProviderBase ArtiklSpecifikacijaTipProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ArtiklSpecifikacijaTipProvider;
			}
		}
		
		#endregion
		
		#region BlagajnaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Blagajna"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static BlagajnaProviderBase BlagajnaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.BlagajnaProvider;
			}
		}
		
		#endregion
		
		#region ArtiklStatusProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ArtiklStatus"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ArtiklStatusProviderBase ArtiklStatusProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ArtiklStatusProvider;
			}
		}
		
		#endregion
		
		#region BlagajnaIzvjestajProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="BlagajnaIzvjestaj"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static BlagajnaIzvjestajProviderBase BlagajnaIzvjestajProvider
		{
			get 
			{
				LoadProviders();
				return _provider.BlagajnaIzvjestajProvider;
			}
		}
		
		#endregion
		
		#region BlagajnaStavkaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="BlagajnaStavka"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static BlagajnaStavkaProviderBase BlagajnaStavkaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.BlagajnaStavkaProvider;
			}
		}
		
		#endregion
		
		#region BankaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Banka"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static BankaProviderBase BankaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.BankaProvider;
			}
		}
		
		#endregion
		
		#region ArtiklSpecifikacijaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ArtiklSpecifikacija"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ArtiklSpecifikacijaProviderBase ArtiklSpecifikacijaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ArtiklSpecifikacijaProvider;
			}
		}
		
		#endregion
		
		#region GrupaDjelatnikProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GrupaDjelatnik"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GrupaDjelatnikProviderBase GrupaDjelatnikProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GrupaDjelatnikProvider;
			}
		}
		
		#endregion
		
		#region ArtiklSpecifikacijaStaticTableProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ArtiklSpecifikacijaStaticTable"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ArtiklSpecifikacijaStaticTableProviderBase ArtiklSpecifikacijaStaticTableProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ArtiklSpecifikacijaStaticTableProvider;
			}
		}
		
		#endregion
		
		#region ArtiklVrijednostiProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ArtiklVrijednosti"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ArtiklVrijednostiProviderBase ArtiklVrijednostiProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ArtiklVrijednostiProvider;
			}
		}
		
		#endregion
		
		#region NetoBrutoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NetoBruto"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NetoBrutoProviderBase NetoBrutoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NetoBrutoProvider;
			}
		}
		
		#endregion
		
		#region MjestoTipProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="MjestoTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MjestoTipProviderBase MjestoTipProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MjestoTipProvider;
			}
		}
		
		#endregion
		
		#region NAppUpdateProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NAppUpdate"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NAppUpdateProviderBase NAppUpdateProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NAppUpdateProvider;
			}
		}
		
		#endregion
		
		#region ObracunProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Obracun"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ObracunProviderBase ObracunProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ObracunProvider;
			}
		}
		
		#endregion
		
		#region NacinTransportaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NacinTransporta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NacinTransportaProviderBase NacinTransportaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NacinTransportaProvider;
			}
		}
		
		#endregion
		
		#region GrupaDjelatnikParametraProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GrupaDjelatnikParametra"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GrupaDjelatnikParametraProviderBase GrupaDjelatnikParametraProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GrupaDjelatnikParametraProvider;
			}
		}
		
		#endregion
		
		#region KontoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Konto"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static KontoProviderBase KontoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.KontoProvider;
			}
		}
		
		#endregion
		
		#region ObracunKamataProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ObracunKamata"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ObracunKamataProviderBase ObracunKamataProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ObracunKamataProvider;
			}
		}
		
		#endregion
		
		#region NacinPlacanjaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NacinPlacanja"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NacinPlacanjaProviderBase NacinPlacanjaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NacinPlacanjaProvider;
			}
		}
		
		#endregion
		
		#region ObracunOsobaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ObracunOsoba"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ObracunOsobaProviderBase ObracunOsobaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ObracunOsobaProvider;
			}
		}
		
		#endregion
		
		#region ObracunKamataProknjizenProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ObracunKamataProknjizen"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ObracunKamataProknjizenProviderBase ObracunKamataProknjizenProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ObracunKamataProknjizenProvider;
			}
		}
		
		#endregion
		
		#region IspisProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Ispis"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static IspisProviderBase IspisProvider
		{
			get 
			{
				LoadProviders();
				return _provider.IspisProvider;
			}
		}
		
		#endregion
		
		#region ObracunOsobaObustavaNaknadaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ObracunOsobaObustavaNaknada"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ObracunOsobaObustavaNaknadaProviderBase ObracunOsobaObustavaNaknadaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ObracunOsobaObustavaNaknadaProvider;
			}
		}
		
		#endregion
		
		#region ObracunKamataShemaKnjizProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ObracunKamataShemaKnjiz"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ObracunKamataShemaKnjizProviderBase ObracunKamataShemaKnjizProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ObracunKamataShemaKnjizProvider;
			}
		}
		
		#endregion
		
		#region IspisKolonaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="IspisKolona"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static IspisKolonaProviderBase IspisKolonaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.IspisKolonaProvider;
			}
		}
		
		#endregion
		
		#region ObracunOsobaPoreznaOlaksicaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ObracunOsobaPoreznaOlaksica"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ObracunOsobaPoreznaOlaksicaProviderBase ObracunOsobaPoreznaOlaksicaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ObracunOsobaPoreznaOlaksicaProvider;
			}
		}
		
		#endregion
		
		#region ObracunKamataStavkeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ObracunKamataStavke"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ObracunKamataStavkeProviderBase ObracunKamataStavkeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ObracunKamataStavkeProvider;
			}
		}
		
		#endregion
		
		#region GrupaDozvoleProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GrupaDozvole"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GrupaDozvoleProviderBase GrupaDozvoleProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GrupaDozvoleProvider;
			}
		}
		
		#endregion
		
		#region GrupaDjelatnikReportProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GrupaDjelatnikReport"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GrupaDjelatnikReportProviderBase GrupaDjelatnikReportProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GrupaDjelatnikReportProvider;
			}
		}
		
		#endregion
		
		#region MjestoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Mjesto"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MjestoProviderBase MjestoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MjestoProvider;
			}
		}
		
		#endregion
		
		#region InvaliditetProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Invaliditet"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static InvaliditetProviderBase InvaliditetProvider
		{
			get 
			{
				LoadProviders();
				return _provider.InvaliditetProvider;
			}
		}
		
		#endregion
		
		#region KlijentProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Klijent"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static KlijentProviderBase KlijentProvider
		{
			get 
			{
				LoadProviders();
				return _provider.KlijentProvider;
			}
		}
		
		#endregion
		
		#region KlijentTipProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="KlijentTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static KlijentTipProviderBase KlijentTipProvider
		{
			get 
			{
				LoadProviders();
				return _provider.KlijentTipProvider;
			}
		}
		
		#endregion
		
		#region KnjizenjeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Knjizenje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static KnjizenjeProviderBase KnjizenjeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.KnjizenjeProvider;
			}
		}
		
		#endregion
		
		#region KnjizenjeStavkaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="KnjizenjeStavka"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static KnjizenjeStavkaProviderBase KnjizenjeStavkaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.KnjizenjeStavkaProvider;
			}
		}
		
		#endregion
		
		#region KlijentNapomenaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="KlijentNapomena"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static KlijentNapomenaProviderBase KlijentNapomenaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.KlijentNapomenaProvider;
			}
		}
		
		#endregion
		
		#region IzvadakProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Izvadak"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static IzvadakProviderBase IzvadakProvider
		{
			get 
			{
				LoadProviders();
				return _provider.IzvadakProvider;
			}
		}
		
		#endregion
		
		#region KlijentOsobaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="KlijentOsoba"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static KlijentOsobaProviderBase KlijentOsobaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.KlijentOsobaProvider;
			}
		}
		
		#endregion
		
		#region KlijentBankovniRacunProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="KlijentBankovniRacun"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static KlijentBankovniRacunProviderBase KlijentBankovniRacunProvider
		{
			get 
			{
				LoadProviders();
				return _provider.KlijentBankovniRacunProvider;
			}
		}
		
		#endregion
		
		#region KontoKolonaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="KontoKolona"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static KontoKolonaProviderBase KontoKolonaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.KontoKolonaProvider;
			}
		}
		
		#endregion
		
		#region ZatvaranjeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Zatvaranje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ZatvaranjeProviderBase ZatvaranjeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ZatvaranjeProvider;
			}
		}
		
		#endregion
		
		
		#region VwArtiklKategorijaProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwArtiklKategorija"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwArtiklKategorijaProviderBase VwArtiklKategorijaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwArtiklKategorijaProvider;
			}
		}
		
		#endregion
		
		#region VwArtiklStanjeuSkladistuProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwArtiklStanjeuSkladistu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwArtiklStanjeuSkladistuProviderBase VwArtiklStanjeuSkladistuProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwArtiklStanjeuSkladistuProvider;
			}
		}
		
		#endregion
		
		#region VwArtiklStanjeVPCProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwArtiklStanjeVPC"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwArtiklStanjeVPCProviderBase VwArtiklStanjeVPCProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwArtiklStanjeVPCProvider;
			}
		}
		
		#endregion
		
		#region VwArtiklTraziProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwArtiklTrazi"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwArtiklTraziProviderBase VwArtiklTraziProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwArtiklTraziProvider;
			}
		}
		
		#endregion
		
		#region VwBankaProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwBanka"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwBankaProviderBase VwBankaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwBankaProvider;
			}
		}
		
		#endregion
		
		#region VwBlagajnaIzvjestajSaldoProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwBlagajnaIzvjestajSaldo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwBlagajnaIzvjestajSaldoProviderBase VwBlagajnaIzvjestajSaldoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwBlagajnaIzvjestajSaldoProvider;
			}
		}
		
		#endregion
		
		#region VwBlagajnaSaldoProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwBlagajnaSaldo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwBlagajnaSaldoProviderBase VwBlagajnaSaldoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwBlagajnaSaldoProvider;
			}
		}
		
		#endregion
		
		#region VwBlagajnaStavkaProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwBlagajnaStavka"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwBlagajnaStavkaProviderBase VwBlagajnaStavkaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwBlagajnaStavkaProvider;
			}
		}
		
		#endregion
		
		#region VwDefParametriDjelatnikaProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwDefParametriDjelatnika"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwDefParametriDjelatnikaProviderBase VwDefParametriDjelatnikaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwDefParametriDjelatnikaProvider;
			}
		}
		
		#endregion
		
		#region VwDokumentProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwDokument"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwDokumentProviderBase VwDokumentProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwDokumentProvider;
			}
		}
		
		#endregion
		
		#region VwDozvoleGrupeProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwDozvoleGrupe"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwDozvoleGrupeProviderBase VwDozvoleGrupeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwDozvoleGrupeProvider;
			}
		}
		
		#endregion
		
		#region VwDozvoleOrganizacijeProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwDozvoleOrganizacije"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwDozvoleOrganizacijeProviderBase VwDozvoleOrganizacijeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwDozvoleOrganizacijeProvider;
			}
		}
		
		#endregion
		
		#region VwIspisProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwIspis"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwIspisProviderBase VwIspisProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwIspisProvider;
			}
		}
		
		#endregion
		
		#region VwIzvadakProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwIzvadak"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwIzvadakProviderBase VwIzvadakProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwIzvadakProvider;
			}
		}
		
		#endregion
		
		#region VwKlijentProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwKlijent"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwKlijentProviderBase VwKlijentProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwKlijentProvider;
			}
		}
		
		#endregion
		
		#region VwKnjizenjeProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwKnjizenje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwKnjizenjeProviderBase VwKnjizenjeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwKnjizenjeProvider;
			}
		}
		
		#endregion
		
		#region VwKnjizenjeIspisProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwKnjizenjeIspis"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwKnjizenjeIspisProviderBase VwKnjizenjeIspisProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwKnjizenjeIspisProvider;
			}
		}
		
		#endregion
		
		#region VwKontoProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwKonto"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwKontoProviderBase VwKontoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwKontoProvider;
			}
		}
		
		#endregion
		
		#region VwKopiranjeDokumentaProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwKopiranjeDokumenta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwKopiranjeDokumentaProviderBase VwKopiranjeDokumentaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwKopiranjeDokumentaProvider;
			}
		}
		
		#endregion
		
		#region VwNc_Po_DobavljacuProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwNc_Po_Dobavljacu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwNc_Po_DobavljacuProviderBase VwNc_Po_DobavljacuProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwNc_Po_DobavljacuProvider;
			}
		}
		
		#endregion
		
		#region VwObracunDefaultVrijednostiProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwObracunDefaultVrijednosti"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwObracunDefaultVrijednostiProviderBase VwObracunDefaultVrijednostiProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwObracunDefaultVrijednostiProvider;
			}
		}
		
		#endregion
		
		#region VwObracunKamataProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwObracunKamata"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwObracunKamataProviderBase VwObracunKamataProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwObracunKamataProvider;
			}
		}
		
		#endregion
		
		#region VwObracunKamataTraziProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwObracunKamataTrazi"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwObracunKamataTraziProviderBase VwObracunKamataTraziProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwObracunKamataTraziProvider;
			}
		}
		
		#endregion
		
		#region VwObracunSpecifikacijaPoBankamaProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwObracunSpecifikacijaPoBankama"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwObracunSpecifikacijaPoBankamaProviderBase VwObracunSpecifikacijaPoBankamaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwObracunSpecifikacijaPoBankamaProvider;
			}
		}
		
		#endregion
		
		#region VwObracunTemeljnicaZaKnjizenjeProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwObracunTemeljnicaZaKnjizenje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwObracunTemeljnicaZaKnjizenjeProviderBase VwObracunTemeljnicaZaKnjizenjeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwObracunTemeljnicaZaKnjizenjeProvider;
			}
		}
		
		#endregion
		
		#region VwObracunTraziProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwObracunTrazi"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwObracunTraziProviderBase VwObracunTraziProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwObracunTraziProvider;
			}
		}
		
		#endregion
		
		#region VwObracunVirmaniProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwObracunVirmani"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwObracunVirmaniProviderBase VwObracunVirmaniProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwObracunVirmaniProvider;
			}
		}
		
		#endregion
		
		#region VwObracunZaIDProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwObracunZaID"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwObracunZaIDProviderBase VwObracunZaIDProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwObracunZaIDProvider;
			}
		}
		
		#endregion
		
		#region VwObracunZaIDPoObrascuProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwObracunZaIDPoObrascu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwObracunZaIDPoObrascuProviderBase VwObracunZaIDPoObrascuProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwObracunZaIDPoObrascuProvider;
			}
		}
		
		#endregion
		
		#region VwObracunZaIDPorezPrirezProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwObracunZaIDPorezPrirez"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwObracunZaIDPorezPrirezProviderBase VwObracunZaIDPorezPrirezProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwObracunZaIDPorezPrirezProvider;
			}
		}
		
		#endregion
		
		#region VwObracunZaIDPorezPrirezPoObrascuProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwObracunZaIDPorezPrirezPoObrascu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwObracunZaIDPorezPrirezPoObrascuProviderBase VwObracunZaIDPorezPrirezPoObrascuProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwObracunZaIDPorezPrirezPoObrascuProvider;
			}
		}
		
		#endregion
		
		#region VwObracunZaRegosStavkeProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwObracunZaRegosStavke"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwObracunZaRegosStavkeProviderBase VwObracunZaRegosStavkeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwObracunZaRegosStavkeProvider;
			}
		}
		
		#endregion
		
		#region VwOrganizacijaTVProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwOrganizacijaTV"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwOrganizacijaTVProviderBase VwOrganizacijaTVProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwOrganizacijaTVProvider;
			}
		}
		
		#endregion
		
		#region VwOsnovnaSredstvaProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwOsnovnaSredstva"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwOsnovnaSredstvaProviderBase VwOsnovnaSredstvaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwOsnovnaSredstvaProvider;
			}
		}
		
		#endregion
		
		#region VwOsobaProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwOsoba"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwOsobaProviderBase VwOsobaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwOsobaProvider;
			}
		}
		
		#endregion
		
		#region VwParametriKorisnikaProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwParametriKorisnika"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwParametriKorisnikaProviderBase VwParametriKorisnikaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwParametriKorisnikaProvider;
			}
		}
		
		#endregion
		
		#region VwPopisPutnihNalogaProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwPopisPutnihNaloga"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwPopisPutnihNalogaProviderBase VwPopisPutnihNalogaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwPopisPutnihNalogaProvider;
			}
		}
		
		#endregion
		
		#region VwPreostaloZaZatvaranjeProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwPreostaloZaZatvaranje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwPreostaloZaZatvaranjeProviderBase VwPreostaloZaZatvaranjeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwPreostaloZaZatvaranjeProvider;
			}
		}
		
		#endregion
		
		#region VwPreostaloZaZatvaranjeZapisanoSimpleProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwPreostaloZaZatvaranjeZapisanoSimple"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwPreostaloZaZatvaranjeZapisanoSimpleProviderBase VwPreostaloZaZatvaranjeZapisanoSimpleProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwPreostaloZaZatvaranjeZapisanoSimpleProvider;
			}
		}
		
		#endregion
		
		#region VwPreostaloZaZatvaranjeZapisanoSimpleSviProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwPreostaloZaZatvaranjeZapisanoSimpleSvi"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwPreostaloZaZatvaranjeZapisanoSimpleSviProviderBase VwPreostaloZaZatvaranjeZapisanoSimpleSviProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwPreostaloZaZatvaranjeZapisanoSimpleSviProvider;
			}
		}
		
		#endregion
		
		#region VwPrijenosRadnogNalogaProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwPrijenosRadnogNaloga"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwPrijenosRadnogNalogaProviderBase VwPrijenosRadnogNalogaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwPrijenosRadnogNalogaProvider;
			}
		}
		
		#endregion
		
		#region VwRabatProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwRabat"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwRabatProviderBase VwRabatProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwRabatProvider;
			}
		}
		
		#endregion
		
		#region VwRadniNalogVezeProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwRadniNalogVeze"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwRadniNalogVezeProviderBase VwRadniNalogVezeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwRadniNalogVezeProvider;
			}
		}
		
		#endregion
		
		#region VwReportProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwReport"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwReportProviderBase VwReportProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwReportProvider;
			}
		}
		
		#endregion
		
		#region VwSKPoDokumentimaPoTipuProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwSKPoDokumentimaPoTipu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwSKPoDokumentimaPoTipuProviderBase VwSKPoDokumentimaPoTipuProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwSKPoDokumentimaPoTipuProvider;
			}
		}
		
		#endregion
		
		#region VwTmpSaldoKlijentaProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwTmpSaldoKlijenta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwTmpSaldoKlijentaProviderBase VwTmpSaldoKlijentaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwTmpSaldoKlijentaProvider;
			}
		}
		
		#endregion
		
		#region VwVezeDokumentaProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwVezeDokumenta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwVezeDokumentaProviderBase VwVezeDokumentaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwVezeDokumentaProvider;
			}
		}
		
		#endregion
		
		#region VwVirmanOdabirProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VwVirmanOdabir"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VwVirmanOdabirProviderBase VwVirmanOdabirProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VwVirmanOdabirProvider;
			}
		}
		
		#endregion
		
		#endregion
	}
	
	#region Query/Filters
		
	#region OsobaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Osoba"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaFilters : OsobaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaFilters class.
		/// </summary>
		public OsobaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaFilters
	
	#region OsobaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OsobaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Osoba"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaQuery : OsobaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaQuery class.
		/// </summary>
		public OsobaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaQuery
		
	#region OsobaBankovniRacunFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OsobaBankovniRacun"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaBankovniRacunFilters : OsobaBankovniRacunFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaBankovniRacunFilters class.
		/// </summary>
		public OsobaBankovniRacunFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaBankovniRacunFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaBankovniRacunFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaBankovniRacunFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaBankovniRacunFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaBankovniRacunFilters
	
	#region OsobaBankovniRacunQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OsobaBankovniRacunParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OsobaBankovniRacun"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaBankovniRacunQuery : OsobaBankovniRacunParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaBankovniRacunQuery class.
		/// </summary>
		public OsobaBankovniRacunQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaBankovniRacunQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaBankovniRacunQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaBankovniRacunQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaBankovniRacunQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaBankovniRacunQuery
		
	#region OsobaPlacaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OsobaPlaca"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaPlacaFilters : OsobaPlacaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaPlacaFilters class.
		/// </summary>
		public OsobaPlacaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaPlacaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaPlacaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaPlacaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaPlacaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaPlacaFilters
	
	#region OsobaPlacaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OsobaPlacaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OsobaPlaca"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaPlacaQuery : OsobaPlacaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaPlacaQuery class.
		/// </summary>
		public OsobaPlacaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaPlacaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaPlacaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaPlacaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaPlacaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaPlacaQuery
		
	#region OsobaOrganizacijskaJedinicaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OsobaOrganizacijskaJedinica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaOrganizacijskaJedinicaFilters : OsobaOrganizacijskaJedinicaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaOrganizacijskaJedinicaFilters class.
		/// </summary>
		public OsobaOrganizacijskaJedinicaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaOrganizacijskaJedinicaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaOrganizacijskaJedinicaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaOrganizacijskaJedinicaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaOrganizacijskaJedinicaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaOrganizacijskaJedinicaFilters
	
	#region OsobaOrganizacijskaJedinicaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OsobaOrganizacijskaJedinicaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OsobaOrganizacijskaJedinica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaOrganizacijskaJedinicaQuery : OsobaOrganizacijskaJedinicaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaOrganizacijskaJedinicaQuery class.
		/// </summary>
		public OsobaOrganizacijskaJedinicaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaOrganizacijskaJedinicaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaOrganizacijskaJedinicaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaOrganizacijskaJedinicaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaOrganizacijskaJedinicaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaOrganizacijskaJedinicaQuery
		
	#region OsobaObustavaNaknadaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OsobaObustavaNaknada"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaObustavaNaknadaFilters : OsobaObustavaNaknadaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaObustavaNaknadaFilters class.
		/// </summary>
		public OsobaObustavaNaknadaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaObustavaNaknadaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaObustavaNaknadaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaObustavaNaknadaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaObustavaNaknadaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaObustavaNaknadaFilters
	
	#region OsobaObustavaNaknadaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OsobaObustavaNaknadaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OsobaObustavaNaknada"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaObustavaNaknadaQuery : OsobaObustavaNaknadaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaObustavaNaknadaQuery class.
		/// </summary>
		public OsobaObustavaNaknadaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaObustavaNaknadaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaObustavaNaknadaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaObustavaNaknadaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaObustavaNaknadaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaObustavaNaknadaQuery
		
	#region OsobaPoreznaOlaksicaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OsobaPoreznaOlaksica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaPoreznaOlaksicaFilters : OsobaPoreznaOlaksicaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaPoreznaOlaksicaFilters class.
		/// </summary>
		public OsobaPoreznaOlaksicaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaPoreznaOlaksicaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaPoreznaOlaksicaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaPoreznaOlaksicaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaPoreznaOlaksicaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaPoreznaOlaksicaFilters
	
	#region OsobaPoreznaOlaksicaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OsobaPoreznaOlaksicaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OsobaPoreznaOlaksica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaPoreznaOlaksicaQuery : OsobaPoreznaOlaksicaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaPoreznaOlaksicaQuery class.
		/// </summary>
		public OsobaPoreznaOlaksicaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaPoreznaOlaksicaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaPoreznaOlaksicaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaPoreznaOlaksicaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaPoreznaOlaksicaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaPoreznaOlaksicaQuery
		
	#region OsobaAdreseFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OsobaAdrese"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaAdreseFilters : OsobaAdreseFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaAdreseFilters class.
		/// </summary>
		public OsobaAdreseFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaAdreseFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaAdreseFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaAdreseFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaAdreseFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaAdreseFilters
	
	#region OsobaAdreseQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OsobaAdreseParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OsobaAdrese"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaAdreseQuery : OsobaAdreseParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaAdreseQuery class.
		/// </summary>
		public OsobaAdreseQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaAdreseQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaAdreseQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaAdreseQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaAdreseQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaAdreseQuery
		
	#region _PostavkeRobnogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="_PostavkeRobnog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class _PostavkeRobnogFilters : _PostavkeRobnogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the _PostavkeRobnogFilters class.
		/// </summary>
		public _PostavkeRobnogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the _PostavkeRobnogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public _PostavkeRobnogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the _PostavkeRobnogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public _PostavkeRobnogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion _PostavkeRobnogFilters
	
	#region _PostavkeRobnogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="_PostavkeRobnogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="_PostavkeRobnog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class _PostavkeRobnogQuery : _PostavkeRobnogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the _PostavkeRobnogQuery class.
		/// </summary>
		public _PostavkeRobnogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the _PostavkeRobnogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public _PostavkeRobnogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the _PostavkeRobnogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public _PostavkeRobnogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion _PostavkeRobnogQuery
		
	#region OsobaRadniOdnosFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OsobaRadniOdnos"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaRadniOdnosFilters : OsobaRadniOdnosFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaRadniOdnosFilters class.
		/// </summary>
		public OsobaRadniOdnosFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaRadniOdnosFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaRadniOdnosFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaRadniOdnosFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaRadniOdnosFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaRadniOdnosFilters
	
	#region OsobaRadniOdnosQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OsobaRadniOdnosParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OsobaRadniOdnos"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaRadniOdnosQuery : OsobaRadniOdnosParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaRadniOdnosQuery class.
		/// </summary>
		public OsobaRadniOdnosQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaRadniOdnosQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaRadniOdnosQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaRadniOdnosQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaRadniOdnosQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaRadniOdnosQuery
		
	#region OsobaRadnoMjestoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OsobaRadnoMjesto"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaRadnoMjestoFilters : OsobaRadnoMjestoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaRadnoMjestoFilters class.
		/// </summary>
		public OsobaRadnoMjestoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaRadnoMjestoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaRadnoMjestoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaRadnoMjestoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaRadnoMjestoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaRadnoMjestoFilters
	
	#region OsobaRadnoMjestoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OsobaRadnoMjestoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OsobaRadnoMjesto"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsobaRadnoMjestoQuery : OsobaRadnoMjestoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsobaRadnoMjestoQuery class.
		/// </summary>
		public OsobaRadnoMjestoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsobaRadnoMjestoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsobaRadnoMjestoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsobaRadnoMjestoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsobaRadnoMjestoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsobaRadnoMjestoQuery
		
	#region PrilagodenDokumentTipFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PrilagodenDokumentTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PrilagodenDokumentTipFilters : PrilagodenDokumentTipFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PrilagodenDokumentTipFilters class.
		/// </summary>
		public PrilagodenDokumentTipFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PrilagodenDokumentTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PrilagodenDokumentTipFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PrilagodenDokumentTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PrilagodenDokumentTipFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PrilagodenDokumentTipFilters
	
	#region PrilagodenDokumentTipQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PrilagodenDokumentTipParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PrilagodenDokumentTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PrilagodenDokumentTipQuery : PrilagodenDokumentTipParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PrilagodenDokumentTipQuery class.
		/// </summary>
		public PrilagodenDokumentTipQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PrilagodenDokumentTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PrilagodenDokumentTipQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PrilagodenDokumentTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PrilagodenDokumentTipQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PrilagodenDokumentTipQuery
		
	#region PorezFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Porez"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PorezFilters : PorezFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PorezFilters class.
		/// </summary>
		public PorezFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PorezFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PorezFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PorezFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PorezFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PorezFilters
	
	#region PorezQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PorezParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Porez"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PorezQuery : PorezParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PorezQuery class.
		/// </summary>
		public PorezQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PorezQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PorezQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PorezQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PorezQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PorezQuery
		
	#region ParametriNaziviFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ParametriNazivi"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ParametriNaziviFilters : ParametriNaziviFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ParametriNaziviFilters class.
		/// </summary>
		public ParametriNaziviFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ParametriNaziviFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ParametriNaziviFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ParametriNaziviFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ParametriNaziviFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ParametriNaziviFilters
	
	#region ParametriNaziviQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ParametriNaziviParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ParametriNazivi"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ParametriNaziviQuery : ParametriNaziviParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ParametriNaziviQuery class.
		/// </summary>
		public ParametriNaziviQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ParametriNaziviQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ParametriNaziviQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ParametriNaziviQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ParametriNaziviQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ParametriNaziviQuery
		
	#region ParametriFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Parametri"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ParametriFilters : ParametriFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ParametriFilters class.
		/// </summary>
		public ParametriFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ParametriFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ParametriFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ParametriFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ParametriFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ParametriFilters
	
	#region ParametriQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ParametriParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Parametri"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ParametriQuery : ParametriParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ParametriQuery class.
		/// </summary>
		public ParametriQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ParametriQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ParametriQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ParametriQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ParametriQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ParametriQuery
		
	#region OSTipRetkaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OSTipRetka"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OSTipRetkaFilters : OSTipRetkaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OSTipRetkaFilters class.
		/// </summary>
		public OSTipRetkaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OSTipRetkaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OSTipRetkaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OSTipRetkaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OSTipRetkaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OSTipRetkaFilters
	
	#region OSTipRetkaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OSTipRetkaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OSTipRetka"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OSTipRetkaQuery : OSTipRetkaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OSTipRetkaQuery class.
		/// </summary>
		public OSTipRetkaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OSTipRetkaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OSTipRetkaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OSTipRetkaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OSTipRetkaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OSTipRetkaQuery
		
	#region PrimanjeTipFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PrimanjeTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PrimanjeTipFilters : PrimanjeTipFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PrimanjeTipFilters class.
		/// </summary>
		public PrimanjeTipFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PrimanjeTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PrimanjeTipFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PrimanjeTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PrimanjeTipFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PrimanjeTipFilters
	
	#region PrimanjeTipQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PrimanjeTipParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PrimanjeTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PrimanjeTipQuery : PrimanjeTipParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PrimanjeTipQuery class.
		/// </summary>
		public PrimanjeTipQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PrimanjeTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PrimanjeTipQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PrimanjeTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PrimanjeTipQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PrimanjeTipQuery
		
	#region OsnovnoSredstvoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OsnovnoSredstvo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsnovnoSredstvoFilters : OsnovnoSredstvoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsnovnoSredstvoFilters class.
		/// </summary>
		public OsnovnoSredstvoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsnovnoSredstvoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsnovnoSredstvoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsnovnoSredstvoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsnovnoSredstvoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsnovnoSredstvoFilters
	
	#region OsnovnoSredstvoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OsnovnoSredstvoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OsnovnoSredstvo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsnovnoSredstvoQuery : OsnovnoSredstvoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsnovnoSredstvoQuery class.
		/// </summary>
		public OsnovnoSredstvoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsnovnoSredstvoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsnovnoSredstvoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsnovnoSredstvoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsnovnoSredstvoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsnovnoSredstvoQuery
		
	#region OrganizacijaTipFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OrganizacijaTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrganizacijaTipFilters : OrganizacijaTipFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrganizacijaTipFilters class.
		/// </summary>
		public OrganizacijaTipFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijaTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrganizacijaTipFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijaTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrganizacijaTipFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrganizacijaTipFilters
	
	#region OrganizacijaTipQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OrganizacijaTipParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OrganizacijaTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrganizacijaTipQuery : OrganizacijaTipParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrganizacijaTipQuery class.
		/// </summary>
		public OrganizacijaTipQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijaTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrganizacijaTipQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijaTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrganizacijaTipQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrganizacijaTipQuery
		
	#region OrganizacijaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Organizacija"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrganizacijaFilters : OrganizacijaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrganizacijaFilters class.
		/// </summary>
		public OrganizacijaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrganizacijaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrganizacijaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrganizacijaFilters
	
	#region OrganizacijaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OrganizacijaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Organizacija"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrganizacijaQuery : OrganizacijaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrganizacijaQuery class.
		/// </summary>
		public OrganizacijaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrganizacijaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrganizacijaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrganizacijaQuery
		
	#region VrstaFinDokumentaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VrstaFinDokumenta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VrstaFinDokumentaFilters : VrstaFinDokumentaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VrstaFinDokumentaFilters class.
		/// </summary>
		public VrstaFinDokumentaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VrstaFinDokumentaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VrstaFinDokumentaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VrstaFinDokumentaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VrstaFinDokumentaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VrstaFinDokumentaFilters
	
	#region VrstaFinDokumentaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VrstaFinDokumentaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VrstaFinDokumenta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VrstaFinDokumentaQuery : VrstaFinDokumentaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VrstaFinDokumentaQuery class.
		/// </summary>
		public VrstaFinDokumentaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VrstaFinDokumentaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VrstaFinDokumentaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VrstaFinDokumentaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VrstaFinDokumentaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VrstaFinDokumentaQuery
		
	#region OrganizacijaZiroRacunFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OrganizacijaZiroRacun"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrganizacijaZiroRacunFilters : OrganizacijaZiroRacunFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrganizacijaZiroRacunFilters class.
		/// </summary>
		public OrganizacijaZiroRacunFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijaZiroRacunFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrganizacijaZiroRacunFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijaZiroRacunFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrganizacijaZiroRacunFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrganizacijaZiroRacunFilters
	
	#region OrganizacijaZiroRacunQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OrganizacijaZiroRacunParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OrganizacijaZiroRacun"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrganizacijaZiroRacunQuery : OrganizacijaZiroRacunParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrganizacijaZiroRacunQuery class.
		/// </summary>
		public OrganizacijaZiroRacunQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijaZiroRacunQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrganizacijaZiroRacunQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijaZiroRacunQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrganizacijaZiroRacunQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrganizacijaZiroRacunQuery
		
	#region TipKontaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TipKonta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TipKontaFilters : TipKontaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TipKontaFilters class.
		/// </summary>
		public TipKontaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TipKontaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TipKontaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TipKontaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TipKontaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TipKontaFilters
	
	#region TipKontaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TipKontaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TipKonta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TipKontaQuery : TipKontaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TipKontaQuery class.
		/// </summary>
		public TipKontaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TipKontaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TipKontaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TipKontaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TipKontaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TipKontaQuery
		
	#region ObustavaNaknadaTipFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ObustavaNaknadaTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObustavaNaknadaTipFilters : ObustavaNaknadaTipFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObustavaNaknadaTipFilters class.
		/// </summary>
		public ObustavaNaknadaTipFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObustavaNaknadaTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObustavaNaknadaTipFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObustavaNaknadaTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObustavaNaknadaTipFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObustavaNaknadaTipFilters
	
	#region ObustavaNaknadaTipQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ObustavaNaknadaTipParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ObustavaNaknadaTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObustavaNaknadaTipQuery : ObustavaNaknadaTipParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObustavaNaknadaTipQuery class.
		/// </summary>
		public ObustavaNaknadaTipQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObustavaNaknadaTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObustavaNaknadaTipQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObustavaNaknadaTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObustavaNaknadaTipQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObustavaNaknadaTipQuery
		
	#region OrganizacijskaJedinicaTipFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OrganizacijskaJedinicaTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrganizacijskaJedinicaTipFilters : OrganizacijskaJedinicaTipFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaTipFilters class.
		/// </summary>
		public OrganizacijskaJedinicaTipFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrganizacijskaJedinicaTipFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrganizacijskaJedinicaTipFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrganizacijskaJedinicaTipFilters
	
	#region OrganizacijskaJedinicaTipQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OrganizacijskaJedinicaTipParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OrganizacijskaJedinicaTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrganizacijskaJedinicaTipQuery : OrganizacijskaJedinicaTipParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaTipQuery class.
		/// </summary>
		public OrganizacijskaJedinicaTipQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrganizacijskaJedinicaTipQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrganizacijskaJedinicaTipQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrganizacijskaJedinicaTipQuery
		
	#region OSKarticaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OSKartica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OSKarticaFilters : OSKarticaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OSKarticaFilters class.
		/// </summary>
		public OSKarticaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OSKarticaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OSKarticaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OSKarticaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OSKarticaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OSKarticaFilters
	
	#region OSKarticaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OSKarticaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OSKartica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OSKarticaQuery : OSKarticaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OSKarticaQuery class.
		/// </summary>
		public OSKarticaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OSKarticaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OSKarticaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OSKarticaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OSKarticaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OSKarticaQuery
		
	#region OrganizacijskaJedinicaZiroRacunFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OrganizacijskaJedinicaZiroRacun"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrganizacijskaJedinicaZiroRacunFilters : OrganizacijskaJedinicaZiroRacunFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaZiroRacunFilters class.
		/// </summary>
		public OrganizacijskaJedinicaZiroRacunFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaZiroRacunFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrganizacijskaJedinicaZiroRacunFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaZiroRacunFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrganizacijskaJedinicaZiroRacunFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrganizacijskaJedinicaZiroRacunFilters
	
	#region OrganizacijskaJedinicaZiroRacunQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OrganizacijskaJedinicaZiroRacunParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OrganizacijskaJedinicaZiroRacun"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrganizacijskaJedinicaZiroRacunQuery : OrganizacijskaJedinicaZiroRacunParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaZiroRacunQuery class.
		/// </summary>
		public OrganizacijskaJedinicaZiroRacunQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaZiroRacunQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrganizacijskaJedinicaZiroRacunQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaZiroRacunQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrganizacijskaJedinicaZiroRacunQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrganizacijskaJedinicaZiroRacunQuery
		
	#region OSGrupaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OSGrupa"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OSGrupaFilters : OSGrupaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OSGrupaFilters class.
		/// </summary>
		public OSGrupaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OSGrupaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OSGrupaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OSGrupaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OSGrupaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OSGrupaFilters
	
	#region OSGrupaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OSGrupaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OSGrupa"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OSGrupaQuery : OSGrupaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OSGrupaQuery class.
		/// </summary>
		public OSGrupaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OSGrupaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OSGrupaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OSGrupaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OSGrupaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OSGrupaQuery
		
	#region OsnovaOsiguranjaTipFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OsnovaOsiguranjaTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsnovaOsiguranjaTipFilters : OsnovaOsiguranjaTipFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsnovaOsiguranjaTipFilters class.
		/// </summary>
		public OsnovaOsiguranjaTipFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsnovaOsiguranjaTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsnovaOsiguranjaTipFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsnovaOsiguranjaTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsnovaOsiguranjaTipFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsnovaOsiguranjaTipFilters
	
	#region OsnovaOsiguranjaTipQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OsnovaOsiguranjaTipParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OsnovaOsiguranjaTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OsnovaOsiguranjaTipQuery : OsnovaOsiguranjaTipParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OsnovaOsiguranjaTipQuery class.
		/// </summary>
		public OsnovaOsiguranjaTipQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OsnovaOsiguranjaTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OsnovaOsiguranjaTipQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OsnovaOsiguranjaTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OsnovaOsiguranjaTipQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OsnovaOsiguranjaTipQuery
		
	#region OrganizacijskaJedinicaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OrganizacijskaJedinica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrganizacijskaJedinicaFilters : OrganizacijskaJedinicaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaFilters class.
		/// </summary>
		public OrganizacijskaJedinicaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrganizacijskaJedinicaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrganizacijskaJedinicaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrganizacijskaJedinicaFilters
	
	#region OrganizacijskaJedinicaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OrganizacijskaJedinicaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OrganizacijskaJedinica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrganizacijskaJedinicaQuery : OrganizacijskaJedinicaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaQuery class.
		/// </summary>
		public OrganizacijskaJedinicaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrganizacijskaJedinicaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrganizacijskaJedinicaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrganizacijskaJedinicaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrganizacijskaJedinicaQuery
		
	#region OSAmortizacijskaGrupaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OSAmortizacijskaGrupa"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OSAmortizacijskaGrupaFilters : OSAmortizacijskaGrupaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OSAmortizacijskaGrupaFilters class.
		/// </summary>
		public OSAmortizacijskaGrupaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OSAmortizacijskaGrupaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OSAmortizacijskaGrupaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OSAmortizacijskaGrupaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OSAmortizacijskaGrupaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OSAmortizacijskaGrupaFilters
	
	#region OSAmortizacijskaGrupaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OSAmortizacijskaGrupaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OSAmortizacijskaGrupa"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OSAmortizacijskaGrupaQuery : OSAmortizacijskaGrupaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OSAmortizacijskaGrupaQuery class.
		/// </summary>
		public OSAmortizacijskaGrupaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OSAmortizacijskaGrupaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OSAmortizacijskaGrupaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OSAmortizacijskaGrupaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OSAmortizacijskaGrupaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OSAmortizacijskaGrupaQuery
		
	#region OSAGPromjenaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OSAGPromjena"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OSAGPromjenaFilters : OSAGPromjenaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OSAGPromjenaFilters class.
		/// </summary>
		public OSAGPromjenaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OSAGPromjenaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OSAGPromjenaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OSAGPromjenaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OSAGPromjenaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OSAGPromjenaFilters
	
	#region OSAGPromjenaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OSAGPromjenaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OSAGPromjena"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OSAGPromjenaQuery : OSAGPromjenaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OSAGPromjenaQuery class.
		/// </summary>
		public OSAGPromjenaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OSAGPromjenaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OSAGPromjenaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OSAGPromjenaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OSAGPromjenaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OSAGPromjenaQuery
		
	#region PutniNalogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PutniNalog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PutniNalogFilters : PutniNalogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PutniNalogFilters class.
		/// </summary>
		public PutniNalogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PutniNalogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PutniNalogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PutniNalogFilters
	
	#region PutniNalogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PutniNalogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PutniNalog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PutniNalogQuery : PutniNalogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PutniNalogQuery class.
		/// </summary>
		public PutniNalogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PutniNalogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PutniNalogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PutniNalogQuery
		
	#region PutniNalogAkontacijaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PutniNalogAkontacija"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PutniNalogAkontacijaFilters : PutniNalogAkontacijaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PutniNalogAkontacijaFilters class.
		/// </summary>
		public PutniNalogAkontacijaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogAkontacijaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PutniNalogAkontacijaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogAkontacijaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PutniNalogAkontacijaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PutniNalogAkontacijaFilters
	
	#region PutniNalogAkontacijaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PutniNalogAkontacijaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PutniNalogAkontacija"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PutniNalogAkontacijaQuery : PutniNalogAkontacijaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PutniNalogAkontacijaQuery class.
		/// </summary>
		public PutniNalogAkontacijaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogAkontacijaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PutniNalogAkontacijaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogAkontacijaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PutniNalogAkontacijaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PutniNalogAkontacijaQuery
		
	#region ValutaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Valuta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ValutaFilters : ValutaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ValutaFilters class.
		/// </summary>
		public ValutaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ValutaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ValutaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ValutaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ValutaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ValutaFilters
	
	#region ValutaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ValutaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Valuta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ValutaQuery : ValutaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ValutaQuery class.
		/// </summary>
		public ValutaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ValutaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ValutaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ValutaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ValutaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ValutaQuery
		
	#region PutniNalogStavkaDnevnicaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PutniNalogStavkaDnevnica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PutniNalogStavkaDnevnicaFilters : PutniNalogStavkaDnevnicaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaDnevnicaFilters class.
		/// </summary>
		public PutniNalogStavkaDnevnicaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaDnevnicaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PutniNalogStavkaDnevnicaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaDnevnicaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PutniNalogStavkaDnevnicaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PutniNalogStavkaDnevnicaFilters
	
	#region PutniNalogStavkaDnevnicaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PutniNalogStavkaDnevnicaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PutniNalogStavkaDnevnica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PutniNalogStavkaDnevnicaQuery : PutniNalogStavkaDnevnicaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaDnevnicaQuery class.
		/// </summary>
		public PutniNalogStavkaDnevnicaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaDnevnicaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PutniNalogStavkaDnevnicaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaDnevnicaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PutniNalogStavkaDnevnicaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PutniNalogStavkaDnevnicaQuery
		
	#region ReportFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Report"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ReportFilters : ReportFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ReportFilters class.
		/// </summary>
		public ReportFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ReportFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ReportFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ReportFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ReportFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ReportFilters
	
	#region ReportQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ReportParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Report"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ReportQuery : ReportParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ReportQuery class.
		/// </summary>
		public ReportQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ReportQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ReportQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ReportQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ReportQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ReportQuery
		
	#region SklDZahtijevStavkeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SklDZahtijevStavke"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SklDZahtijevStavkeFilters : SklDZahtijevStavkeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SklDZahtijevStavkeFilters class.
		/// </summary>
		public SklDZahtijevStavkeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SklDZahtijevStavkeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SklDZahtijevStavkeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SklDZahtijevStavkeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SklDZahtijevStavkeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SklDZahtijevStavkeFilters
	
	#region SklDZahtijevStavkeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SklDZahtijevStavkeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SklDZahtijevStavke"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SklDZahtijevStavkeQuery : SklDZahtijevStavkeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SklDZahtijevStavkeQuery class.
		/// </summary>
		public SklDZahtijevStavkeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SklDZahtijevStavkeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SklDZahtijevStavkeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SklDZahtijevStavkeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SklDZahtijevStavkeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SklDZahtijevStavkeQuery
		
	#region SklDLagerFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SklDLager"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SklDLagerFilters : SklDLagerFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SklDLagerFilters class.
		/// </summary>
		public SklDLagerFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SklDLagerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SklDLagerFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SklDLagerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SklDLagerFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SklDLagerFilters
	
	#region SklDLagerQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SklDLagerParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SklDLager"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SklDLagerQuery : SklDLagerParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SklDLagerQuery class.
		/// </summary>
		public SklDLagerQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SklDLagerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SklDLagerQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SklDLagerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SklDLagerQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SklDLagerQuery
		
	#region SifarnikTipFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SifarnikTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SifarnikTipFilters : SifarnikTipFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SifarnikTipFilters class.
		/// </summary>
		public SifarnikTipFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SifarnikTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SifarnikTipFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SifarnikTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SifarnikTipFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SifarnikTipFilters
	
	#region SifarnikTipQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SifarnikTipParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SifarnikTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SifarnikTipQuery : SifarnikTipParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SifarnikTipQuery class.
		/// </summary>
		public SifarnikTipQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SifarnikTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SifarnikTipQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SifarnikTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SifarnikTipQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SifarnikTipQuery
		
	#region SklDZahtjevGlavaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SklDZahtjevGlava"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SklDZahtjevGlavaFilters : SklDZahtjevGlavaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SklDZahtjevGlavaFilters class.
		/// </summary>
		public SklDZahtjevGlavaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SklDZahtjevGlavaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SklDZahtjevGlavaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SklDZahtjevGlavaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SklDZahtjevGlavaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SklDZahtjevGlavaFilters
	
	#region SklDZahtjevGlavaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SklDZahtjevGlavaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SklDZahtjevGlava"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SklDZahtjevGlavaQuery : SklDZahtjevGlavaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SklDZahtjevGlavaQuery class.
		/// </summary>
		public SklDZahtjevGlavaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SklDZahtjevGlavaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SklDZahtjevGlavaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SklDZahtjevGlavaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SklDZahtjevGlavaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SklDZahtjevGlavaQuery
		
	#region SifarnikFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Sifarnik"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SifarnikFilters : SifarnikFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SifarnikFilters class.
		/// </summary>
		public SifarnikFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SifarnikFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SifarnikFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SifarnikFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SifarnikFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SifarnikFilters
	
	#region SifarnikQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SifarnikParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Sifarnik"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SifarnikQuery : SifarnikParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SifarnikQuery class.
		/// </summary>
		public SifarnikQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SifarnikQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SifarnikQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SifarnikQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SifarnikQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SifarnikQuery
		
	#region TecajValuteFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TecajValute"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TecajValuteFilters : TecajValuteFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TecajValuteFilters class.
		/// </summary>
		public TecajValuteFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TecajValuteFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TecajValuteFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TecajValuteFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TecajValuteFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TecajValuteFilters
	
	#region TecajValuteQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TecajValuteParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TecajValute"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TecajValuteQuery : TecajValuteParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TecajValuteQuery class.
		/// </summary>
		public TecajValuteQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TecajValuteQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TecajValuteQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TecajValuteQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TecajValuteQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TecajValuteQuery
		
	#region VrstaRaspodjeleFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VrstaRaspodjele"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VrstaRaspodjeleFilters : VrstaRaspodjeleFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VrstaRaspodjeleFilters class.
		/// </summary>
		public VrstaRaspodjeleFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VrstaRaspodjeleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VrstaRaspodjeleFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VrstaRaspodjeleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VrstaRaspodjeleFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VrstaRaspodjeleFilters
	
	#region VrstaRaspodjeleQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VrstaRaspodjeleParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VrstaRaspodjele"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VrstaRaspodjeleQuery : VrstaRaspodjeleParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VrstaRaspodjeleQuery class.
		/// </summary>
		public VrstaRaspodjeleQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VrstaRaspodjeleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VrstaRaspodjeleQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VrstaRaspodjeleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VrstaRaspodjeleQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VrstaRaspodjeleQuery
		
	#region VoziloFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Vozilo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VoziloFilters : VoziloFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VoziloFilters class.
		/// </summary>
		public VoziloFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VoziloFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VoziloFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VoziloFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VoziloFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VoziloFilters
	
	#region VoziloQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VoziloParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Vozilo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VoziloQuery : VoziloParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VoziloQuery class.
		/// </summary>
		public VoziloQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VoziloQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VoziloQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VoziloQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VoziloQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VoziloQuery
		
	#region VirmanFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Virman"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VirmanFilters : VirmanFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VirmanFilters class.
		/// </summary>
		public VirmanFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VirmanFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VirmanFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VirmanFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VirmanFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VirmanFilters
	
	#region VirmanQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VirmanParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Virman"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VirmanQuery : VirmanParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VirmanQuery class.
		/// </summary>
		public VirmanQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VirmanQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VirmanQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VirmanQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VirmanQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VirmanQuery
		
	#region VezaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Veza"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VezaFilters : VezaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VezaFilters class.
		/// </summary>
		public VezaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VezaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VezaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VezaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VezaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VezaFilters
	
	#region VezaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VezaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Veza"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VezaQuery : VezaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VezaQuery class.
		/// </summary>
		public VezaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VezaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VezaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VezaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VezaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VezaQuery
		
	#region TipIspisaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TipIspisa"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TipIspisaFilters : TipIspisaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TipIspisaFilters class.
		/// </summary>
		public TipIspisaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TipIspisaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TipIspisaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TipIspisaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TipIspisaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TipIspisaFilters
	
	#region TipIspisaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TipIspisaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TipIspisa"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TipIspisaQuery : TipIspisaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TipIspisaQuery class.
		/// </summary>
		public TipIspisaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TipIspisaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TipIspisaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TipIspisaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TipIspisaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TipIspisaQuery
		
	#region ShemaKnjizenjeNazivKolonaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ShemaKnjizenjeNazivKolona"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ShemaKnjizenjeNazivKolonaFilters : ShemaKnjizenjeNazivKolonaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ShemaKnjizenjeNazivKolonaFilters class.
		/// </summary>
		public ShemaKnjizenjeNazivKolonaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ShemaKnjizenjeNazivKolonaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ShemaKnjizenjeNazivKolonaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ShemaKnjizenjeNazivKolonaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ShemaKnjizenjeNazivKolonaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ShemaKnjizenjeNazivKolonaFilters
	
	#region ShemaKnjizenjeNazivKolonaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ShemaKnjizenjeNazivKolonaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ShemaKnjizenjeNazivKolona"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ShemaKnjizenjeNazivKolonaQuery : ShemaKnjizenjeNazivKolonaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ShemaKnjizenjeNazivKolonaQuery class.
		/// </summary>
		public ShemaKnjizenjeNazivKolonaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ShemaKnjizenjeNazivKolonaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ShemaKnjizenjeNazivKolonaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ShemaKnjizenjeNazivKolonaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ShemaKnjizenjeNazivKolonaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ShemaKnjizenjeNazivKolonaQuery
		
	#region ShemaKnjizenjaRobnoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ShemaKnjizenjaRobno"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ShemaKnjizenjaRobnoFilters : ShemaKnjizenjaRobnoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ShemaKnjizenjaRobnoFilters class.
		/// </summary>
		public ShemaKnjizenjaRobnoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ShemaKnjizenjaRobnoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ShemaKnjizenjaRobnoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ShemaKnjizenjaRobnoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ShemaKnjizenjaRobnoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ShemaKnjizenjaRobnoFilters
	
	#region ShemaKnjizenjaRobnoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ShemaKnjizenjaRobnoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ShemaKnjizenjaRobno"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ShemaKnjizenjaRobnoQuery : ShemaKnjizenjaRobnoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ShemaKnjizenjaRobnoQuery class.
		/// </summary>
		public ShemaKnjizenjaRobnoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ShemaKnjizenjaRobnoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ShemaKnjizenjaRobnoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ShemaKnjizenjaRobnoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ShemaKnjizenjaRobnoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ShemaKnjizenjaRobnoQuery
		
	#region ReportPivotsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ReportPivots"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ReportPivotsFilters : ReportPivotsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ReportPivotsFilters class.
		/// </summary>
		public ReportPivotsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ReportPivotsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ReportPivotsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ReportPivotsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ReportPivotsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ReportPivotsFilters
	
	#region ReportPivotsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ReportPivotsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ReportPivots"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ReportPivotsQuery : ReportPivotsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ReportPivotsQuery class.
		/// </summary>
		public ReportPivotsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ReportPivotsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ReportPivotsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ReportPivotsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ReportPivotsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ReportPivotsQuery
		
	#region RadniNalogVezaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="RadniNalogVeza"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RadniNalogVezaFilters : RadniNalogVezaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RadniNalogVezaFilters class.
		/// </summary>
		public RadniNalogVezaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the RadniNalogVezaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RadniNalogVezaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RadniNalogVezaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RadniNalogVezaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RadniNalogVezaFilters
	
	#region RadniNalogVezaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="RadniNalogVezaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="RadniNalogVeza"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RadniNalogVezaQuery : RadniNalogVezaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RadniNalogVezaQuery class.
		/// </summary>
		public RadniNalogVezaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the RadniNalogVezaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RadniNalogVezaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RadniNalogVezaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RadniNalogVezaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RadniNalogVezaQuery
		
	#region RabatFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Rabat"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RabatFilters : RabatFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RabatFilters class.
		/// </summary>
		public RabatFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the RabatFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RabatFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RabatFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RabatFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RabatFilters
	
	#region RabatQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="RabatParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Rabat"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RabatQuery : RabatParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RabatQuery class.
		/// </summary>
		public RabatQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the RabatQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RabatQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RabatQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RabatQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RabatQuery
		
	#region PutniNalogStavkaOstaloFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PutniNalogStavkaOstalo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PutniNalogStavkaOstaloFilters : PutniNalogStavkaOstaloFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaOstaloFilters class.
		/// </summary>
		public PutniNalogStavkaOstaloFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaOstaloFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PutniNalogStavkaOstaloFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaOstaloFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PutniNalogStavkaOstaloFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PutniNalogStavkaOstaloFilters
	
	#region PutniNalogStavkaOstaloQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PutniNalogStavkaOstaloParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PutniNalogStavkaOstalo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PutniNalogStavkaOstaloQuery : PutniNalogStavkaOstaloParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaOstaloQuery class.
		/// </summary>
		public PutniNalogStavkaOstaloQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaOstaloQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PutniNalogStavkaOstaloQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaOstaloQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PutniNalogStavkaOstaloQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PutniNalogStavkaOstaloQuery
		
	#region PutniNalogStavkaPrijevozFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PutniNalogStavkaPrijevoz"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PutniNalogStavkaPrijevozFilters : PutniNalogStavkaPrijevozFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaPrijevozFilters class.
		/// </summary>
		public PutniNalogStavkaPrijevozFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaPrijevozFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PutniNalogStavkaPrijevozFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaPrijevozFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PutniNalogStavkaPrijevozFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PutniNalogStavkaPrijevozFilters
	
	#region PutniNalogStavkaPrijevozQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PutniNalogStavkaPrijevozParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PutniNalogStavkaPrijevoz"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PutniNalogStavkaPrijevozQuery : PutniNalogStavkaPrijevozParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaPrijevozQuery class.
		/// </summary>
		public PutniNalogStavkaPrijevozQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaPrijevozQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PutniNalogStavkaPrijevozQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PutniNalogStavkaPrijevozQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PutniNalogStavkaPrijevozQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PutniNalogStavkaPrijevozQuery
		
	#region RadniOdnosTipFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="RadniOdnosTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RadniOdnosTipFilters : RadniOdnosTipFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RadniOdnosTipFilters class.
		/// </summary>
		public RadniOdnosTipFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the RadniOdnosTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RadniOdnosTipFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RadniOdnosTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RadniOdnosTipFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RadniOdnosTipFilters
	
	#region RadniOdnosTipQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="RadniOdnosTipParameterBuilder"/> class
	/// that is used exclusively with a <see cref="RadniOdnosTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RadniOdnosTipQuery : RadniOdnosTipParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RadniOdnosTipQuery class.
		/// </summary>
		public RadniOdnosTipQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the RadniOdnosTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RadniOdnosTipQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RadniOdnosTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RadniOdnosTipQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RadniOdnosTipQuery
		
	#region RabatSpecFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="RabatSpec"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RabatSpecFilters : RabatSpecFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RabatSpecFilters class.
		/// </summary>
		public RabatSpecFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the RabatSpecFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RabatSpecFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RabatSpecFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RabatSpecFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RabatSpecFilters
	
	#region RabatSpecQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="RabatSpecParameterBuilder"/> class
	/// that is used exclusively with a <see cref="RabatSpec"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RabatSpecQuery : RabatSpecParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RabatSpecQuery class.
		/// </summary>
		public RabatSpecQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the RabatSpecQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RabatSpecQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RabatSpecQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RabatSpecQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RabatSpecQuery
		
	#region RadnoMjestoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="RadnoMjesto"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RadnoMjestoFilters : RadnoMjestoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RadnoMjestoFilters class.
		/// </summary>
		public RadnoMjestoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the RadnoMjestoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RadnoMjestoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RadnoMjestoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RadnoMjestoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RadnoMjestoFilters
	
	#region RadnoMjestoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="RadnoMjestoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="RadnoMjesto"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RadnoMjestoQuery : RadnoMjestoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RadnoMjestoQuery class.
		/// </summary>
		public RadnoMjestoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the RadnoMjestoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RadnoMjestoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RadnoMjestoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RadnoMjestoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RadnoMjestoQuery
		
	#region ReportKolumnaTipFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ReportKolumnaTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ReportKolumnaTipFilters : ReportKolumnaTipFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ReportKolumnaTipFilters class.
		/// </summary>
		public ReportKolumnaTipFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ReportKolumnaTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ReportKolumnaTipFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ReportKolumnaTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ReportKolumnaTipFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ReportKolumnaTipFilters
	
	#region ReportKolumnaTipQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ReportKolumnaTipParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ReportKolumnaTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ReportKolumnaTipQuery : ReportKolumnaTipParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ReportKolumnaTipQuery class.
		/// </summary>
		public ReportKolumnaTipQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ReportKolumnaTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ReportKolumnaTipQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ReportKolumnaTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ReportKolumnaTipQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ReportKolumnaTipQuery
		
	#region ReportKolumnaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ReportKolumna"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ReportKolumnaFilters : ReportKolumnaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ReportKolumnaFilters class.
		/// </summary>
		public ReportKolumnaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ReportKolumnaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ReportKolumnaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ReportKolumnaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ReportKolumnaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ReportKolumnaFilters
	
	#region ReportKolumnaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ReportKolumnaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ReportKolumna"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ReportKolumnaQuery : ReportKolumnaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ReportKolumnaQuery class.
		/// </summary>
		public ReportKolumnaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ReportKolumnaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ReportKolumnaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ReportKolumnaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ReportKolumnaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ReportKolumnaQuery
		
	#region ReportiServerFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ReportiServer"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ReportiServerFilters : ReportiServerFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ReportiServerFilters class.
		/// </summary>
		public ReportiServerFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ReportiServerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ReportiServerFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ReportiServerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ReportiServerFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ReportiServerFilters
	
	#region ReportiServerQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ReportiServerParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ReportiServer"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ReportiServerQuery : ReportiServerParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ReportiServerQuery class.
		/// </summary>
		public ReportiServerQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ReportiServerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ReportiServerQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ReportiServerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ReportiServerQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ReportiServerQuery
		
	#region RazdobljeStopaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="RazdobljeStopa"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RazdobljeStopaFilters : RazdobljeStopaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RazdobljeStopaFilters class.
		/// </summary>
		public RazdobljeStopaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the RazdobljeStopaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RazdobljeStopaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RazdobljeStopaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RazdobljeStopaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RazdobljeStopaFilters
	
	#region RazdobljeStopaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="RazdobljeStopaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="RazdobljeStopa"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RazdobljeStopaQuery : RazdobljeStopaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RazdobljeStopaQuery class.
		/// </summary>
		public RazdobljeStopaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the RazdobljeStopaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RazdobljeStopaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RazdobljeStopaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RazdobljeStopaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RazdobljeStopaQuery
		
	#region RazdobljeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Razdoblje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RazdobljeFilters : RazdobljeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RazdobljeFilters class.
		/// </summary>
		public RazdobljeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the RazdobljeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RazdobljeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RazdobljeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RazdobljeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RazdobljeFilters
	
	#region RazdobljeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="RazdobljeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Razdoblje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RazdobljeQuery : RazdobljeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RazdobljeQuery class.
		/// </summary>
		public RazdobljeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the RazdobljeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RazdobljeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RazdobljeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RazdobljeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RazdobljeQuery
		
	#region ObracunVirmanFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ObracunVirman"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunVirmanFilters : ObracunVirmanFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunVirmanFilters class.
		/// </summary>
		public ObracunVirmanFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunVirmanFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunVirmanFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunVirmanFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunVirmanFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunVirmanFilters
	
	#region ObracunVirmanQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ObracunVirmanParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ObracunVirman"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunVirmanQuery : ObracunVirmanParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunVirmanQuery class.
		/// </summary>
		public ObracunVirmanQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunVirmanQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunVirmanQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunVirmanQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunVirmanQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunVirmanQuery
		
	#region ObracunRSMFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ObracunRSM"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunRSMFilters : ObracunRSMFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunRSMFilters class.
		/// </summary>
		public ObracunRSMFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunRSMFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunRSMFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunRSMFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunRSMFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunRSMFilters
	
	#region ObracunRSMQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ObracunRSMParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ObracunRSM"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunRSMQuery : ObracunRSMParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunRSMQuery class.
		/// </summary>
		public ObracunRSMQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunRSMQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunRSMQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunRSMQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunRSMQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunRSMQuery
		
	#region DokumentFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Dokument"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentFilters : DokumentFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentFilters class.
		/// </summary>
		public DokumentFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentFilters
	
	#region DokumentQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DokumentParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Dokument"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentQuery : DokumentParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentQuery class.
		/// </summary>
		public DokumentQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentQuery
		
	#region DokumentPlacanjeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DokumentPlacanje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentPlacanjeFilters : DokumentPlacanjeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentPlacanjeFilters class.
		/// </summary>
		public DokumentPlacanjeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentPlacanjeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentPlacanjeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentPlacanjeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentPlacanjeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentPlacanjeFilters
	
	#region DokumentPlacanjeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DokumentPlacanjeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DokumentPlacanje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentPlacanjeQuery : DokumentPlacanjeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentPlacanjeQuery class.
		/// </summary>
		public DokumentPlacanjeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentPlacanjeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentPlacanjeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentPlacanjeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentPlacanjeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentPlacanjeQuery
		
	#region ObracunOsobaPrimanjeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ObracunOsobaPrimanje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunOsobaPrimanjeFilters : ObracunOsobaPrimanjeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaPrimanjeFilters class.
		/// </summary>
		public ObracunOsobaPrimanjeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaPrimanjeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunOsobaPrimanjeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaPrimanjeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunOsobaPrimanjeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunOsobaPrimanjeFilters
	
	#region ObracunOsobaPrimanjeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ObracunOsobaPrimanjeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ObracunOsobaPrimanje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunOsobaPrimanjeQuery : ObracunOsobaPrimanjeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaPrimanjeQuery class.
		/// </summary>
		public ObracunOsobaPrimanjeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaPrimanjeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunOsobaPrimanjeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaPrimanjeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunOsobaPrimanjeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunOsobaPrimanjeQuery
		
	#region DokumentTipFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DokumentTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentTipFilters : DokumentTipFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentTipFilters class.
		/// </summary>
		public DokumentTipFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentTipFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentTipFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentTipFilters
	
	#region DokumentTipQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DokumentTipParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DokumentTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentTipQuery : DokumentTipParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentTipQuery class.
		/// </summary>
		public DokumentTipQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentTipQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentTipQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentTipQuery
		
	#region DjelatnikFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Djelatnik"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DjelatnikFilters : DjelatnikFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DjelatnikFilters class.
		/// </summary>
		public DjelatnikFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DjelatnikFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DjelatnikFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DjelatnikFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DjelatnikFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DjelatnikFilters
	
	#region DjelatnikQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DjelatnikParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Djelatnik"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DjelatnikQuery : DjelatnikParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DjelatnikQuery class.
		/// </summary>
		public DjelatnikQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DjelatnikQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DjelatnikQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DjelatnikQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DjelatnikQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DjelatnikQuery
		
	#region DokumentDodatakFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DokumentDodatak"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentDodatakFilters : DokumentDodatakFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentDodatakFilters class.
		/// </summary>
		public DokumentDodatakFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentDodatakFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentDodatakFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentDodatakFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentDodatakFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentDodatakFilters
	
	#region DokumentDodatakQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DokumentDodatakParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DokumentDodatak"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentDodatakQuery : DokumentDodatakParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentDodatakQuery class.
		/// </summary>
		public DokumentDodatakQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentDodatakQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentDodatakQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentDodatakQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentDodatakQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentDodatakQuery
		
	#region DokumentStavkaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DokumentStavka"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentStavkaFilters : DokumentStavkaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentStavkaFilters class.
		/// </summary>
		public DokumentStavkaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentStavkaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentStavkaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentStavkaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentStavkaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentStavkaFilters
	
	#region DokumentStavkaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DokumentStavkaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DokumentStavka"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentStavkaQuery : DokumentStavkaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentStavkaQuery class.
		/// </summary>
		public DokumentStavkaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentStavkaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentStavkaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentStavkaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentStavkaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentStavkaQuery
		
	#region DnevnicaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Dnevnica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DnevnicaFilters : DnevnicaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DnevnicaFilters class.
		/// </summary>
		public DnevnicaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DnevnicaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DnevnicaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DnevnicaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DnevnicaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DnevnicaFilters
	
	#region DnevnicaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DnevnicaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Dnevnica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DnevnicaQuery : DnevnicaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DnevnicaQuery class.
		/// </summary>
		public DnevnicaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DnevnicaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DnevnicaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DnevnicaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DnevnicaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DnevnicaQuery
		
	#region DjelatnikInGrupaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DjelatnikInGrupa"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DjelatnikInGrupaFilters : DjelatnikInGrupaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DjelatnikInGrupaFilters class.
		/// </summary>
		public DjelatnikInGrupaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DjelatnikInGrupaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DjelatnikInGrupaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DjelatnikInGrupaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DjelatnikInGrupaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DjelatnikInGrupaFilters
	
	#region DjelatnikInGrupaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DjelatnikInGrupaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DjelatnikInGrupa"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DjelatnikInGrupaQuery : DjelatnikInGrupaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DjelatnikInGrupaQuery class.
		/// </summary>
		public DjelatnikInGrupaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DjelatnikInGrupaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DjelatnikInGrupaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DjelatnikInGrupaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DjelatnikInGrupaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DjelatnikInGrupaQuery
		
	#region DokumentStavkaOpisFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DokumentStavkaOpis"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentStavkaOpisFilters : DokumentStavkaOpisFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentStavkaOpisFilters class.
		/// </summary>
		public DokumentStavkaOpisFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentStavkaOpisFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentStavkaOpisFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentStavkaOpisFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentStavkaOpisFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentStavkaOpisFilters
	
	#region DokumentStavkaOpisQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DokumentStavkaOpisParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DokumentStavkaOpis"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentStavkaOpisQuery : DokumentStavkaOpisParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentStavkaOpisQuery class.
		/// </summary>
		public DokumentStavkaOpisQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentStavkaOpisQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentStavkaOpisQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentStavkaOpisQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentStavkaOpisQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentStavkaOpisQuery
		
	#region DokumentZaglavljeSpecTipFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DokumentZaglavljeSpecTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentZaglavljeSpecTipFilters : DokumentZaglavljeSpecTipFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecTipFilters class.
		/// </summary>
		public DokumentZaglavljeSpecTipFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentZaglavljeSpecTipFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentZaglavljeSpecTipFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentZaglavljeSpecTipFilters
	
	#region DokumentZaglavljeSpecTipQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DokumentZaglavljeSpecTipParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DokumentZaglavljeSpecTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentZaglavljeSpecTipQuery : DokumentZaglavljeSpecTipParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecTipQuery class.
		/// </summary>
		public DokumentZaglavljeSpecTipQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentZaglavljeSpecTipQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentZaglavljeSpecTipQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentZaglavljeSpecTipQuery
		
	#region DokumentZaglavljeSpecPostavkeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DokumentZaglavljeSpecPostavke"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentZaglavljeSpecPostavkeFilters : DokumentZaglavljeSpecPostavkeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecPostavkeFilters class.
		/// </summary>
		public DokumentZaglavljeSpecPostavkeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecPostavkeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentZaglavljeSpecPostavkeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecPostavkeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentZaglavljeSpecPostavkeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentZaglavljeSpecPostavkeFilters
	
	#region DokumentZaglavljeSpecPostavkeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DokumentZaglavljeSpecPostavkeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DokumentZaglavljeSpecPostavke"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentZaglavljeSpecPostavkeQuery : DokumentZaglavljeSpecPostavkeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecPostavkeQuery class.
		/// </summary>
		public DokumentZaglavljeSpecPostavkeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecPostavkeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentZaglavljeSpecPostavkeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecPostavkeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentZaglavljeSpecPostavkeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentZaglavljeSpecPostavkeQuery
		
	#region GrupaParametraFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GrupaParametra"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrupaParametraFilters : GrupaParametraFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrupaParametraFilters class.
		/// </summary>
		public GrupaParametraFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrupaParametraFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrupaParametraFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrupaParametraFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrupaParametraFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrupaParametraFilters
	
	#region GrupaParametraQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GrupaParametraParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GrupaParametra"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrupaParametraQuery : GrupaParametraParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrupaParametraQuery class.
		/// </summary>
		public GrupaParametraQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrupaParametraQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrupaParametraQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrupaParametraQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrupaParametraQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrupaParametraQuery
		
	#region DokumentZaglavljeSpecDokTipFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DokumentZaglavljeSpecDokTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentZaglavljeSpecDokTipFilters : DokumentZaglavljeSpecDokTipFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecDokTipFilters class.
		/// </summary>
		public DokumentZaglavljeSpecDokTipFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecDokTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentZaglavljeSpecDokTipFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecDokTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentZaglavljeSpecDokTipFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentZaglavljeSpecDokTipFilters
	
	#region DokumentZaglavljeSpecDokTipQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DokumentZaglavljeSpecDokTipParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DokumentZaglavljeSpecDokTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentZaglavljeSpecDokTipQuery : DokumentZaglavljeSpecDokTipParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecDokTipQuery class.
		/// </summary>
		public DokumentZaglavljeSpecDokTipQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecDokTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentZaglavljeSpecDokTipQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeSpecDokTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentZaglavljeSpecDokTipQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentZaglavljeSpecDokTipQuery
		
	#region DokumentZaglavljeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DokumentZaglavlje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentZaglavljeFilters : DokumentZaglavljeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeFilters class.
		/// </summary>
		public DokumentZaglavljeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentZaglavljeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentZaglavljeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentZaglavljeFilters
	
	#region DokumentZaglavljeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DokumentZaglavljeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DokumentZaglavlje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DokumentZaglavljeQuery : DokumentZaglavljeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeQuery class.
		/// </summary>
		public DokumentZaglavljeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DokumentZaglavljeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DokumentZaglavljeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DokumentZaglavljeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DokumentZaglavljeQuery
		
	#region DefParametraFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DefParametra"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DefParametraFilters : DefParametraFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DefParametraFilters class.
		/// </summary>
		public DefParametraFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DefParametraFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DefParametraFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DefParametraFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DefParametraFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DefParametraFilters
	
	#region DefParametraQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DefParametraParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DefParametra"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DefParametraQuery : DefParametraParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DefParametraQuery class.
		/// </summary>
		public DefParametraQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DefParametraQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DefParametraQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DefParametraQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DefParametraQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DefParametraQuery
		
	#region BlagdanFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Blagdan"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BlagdanFilters : BlagdanFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BlagdanFilters class.
		/// </summary>
		public BlagdanFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the BlagdanFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BlagdanFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BlagdanFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BlagdanFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BlagdanFilters
	
	#region BlagdanQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="BlagdanParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Blagdan"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BlagdanQuery : BlagdanParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BlagdanQuery class.
		/// </summary>
		public BlagdanQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the BlagdanQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BlagdanQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BlagdanQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BlagdanQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BlagdanQuery
		
	#region ArtiklMjeraFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ArtiklMjera"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ArtiklMjeraFilters : ArtiklMjeraFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ArtiklMjeraFilters class.
		/// </summary>
		public ArtiklMjeraFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ArtiklMjeraFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ArtiklMjeraFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ArtiklMjeraFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ArtiklMjeraFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ArtiklMjeraFilters
	
	#region ArtiklMjeraQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ArtiklMjeraParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ArtiklMjera"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ArtiklMjeraQuery : ArtiklMjeraParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ArtiklMjeraQuery class.
		/// </summary>
		public ArtiklMjeraQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ArtiklMjeraQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ArtiklMjeraQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ArtiklMjeraQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ArtiklMjeraQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ArtiklMjeraQuery
		
	#region ArtiklKategorijaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ArtiklKategorija"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ArtiklKategorijaFilters : ArtiklKategorijaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ArtiklKategorijaFilters class.
		/// </summary>
		public ArtiklKategorijaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ArtiklKategorijaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ArtiklKategorijaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ArtiklKategorijaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ArtiklKategorijaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ArtiklKategorijaFilters
	
	#region ArtiklKategorijaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ArtiklKategorijaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ArtiklKategorija"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ArtiklKategorijaQuery : ArtiklKategorijaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ArtiklKategorijaQuery class.
		/// </summary>
		public ArtiklKategorijaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ArtiklKategorijaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ArtiklKategorijaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ArtiklKategorijaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ArtiklKategorijaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ArtiklKategorijaQuery
		
	#region ArtiklFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Artikl"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ArtiklFilters : ArtiklFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ArtiklFilters class.
		/// </summary>
		public ArtiklFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ArtiklFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ArtiklFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ArtiklFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ArtiklFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ArtiklFilters
	
	#region ArtiklQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ArtiklParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Artikl"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ArtiklQuery : ArtiklParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ArtiklQuery class.
		/// </summary>
		public ArtiklQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ArtiklQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ArtiklQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ArtiklQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ArtiklQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ArtiklQuery
		
	#region AdresaTipFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="AdresaTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdresaTipFilters : AdresaTipFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdresaTipFilters class.
		/// </summary>
		public AdresaTipFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdresaTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdresaTipFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdresaTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdresaTipFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdresaTipFilters
	
	#region AdresaTipQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AdresaTipParameterBuilder"/> class
	/// that is used exclusively with a <see cref="AdresaTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdresaTipQuery : AdresaTipParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdresaTipQuery class.
		/// </summary>
		public AdresaTipQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdresaTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdresaTipQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdresaTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdresaTipQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdresaTipQuery
		
	#region _PostavkeServeraFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="_PostavkeServera"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class _PostavkeServeraFilters : _PostavkeServeraFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the _PostavkeServeraFilters class.
		/// </summary>
		public _PostavkeServeraFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the _PostavkeServeraFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public _PostavkeServeraFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the _PostavkeServeraFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public _PostavkeServeraFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion _PostavkeServeraFilters
	
	#region _PostavkeServeraQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="_PostavkeServeraParameterBuilder"/> class
	/// that is used exclusively with a <see cref="_PostavkeServera"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class _PostavkeServeraQuery : _PostavkeServeraParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the _PostavkeServeraQuery class.
		/// </summary>
		public _PostavkeServeraQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the _PostavkeServeraQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public _PostavkeServeraQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the _PostavkeServeraQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public _PostavkeServeraQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion _PostavkeServeraQuery
		
	#region ArtiklSpecifikacijaTipFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ArtiklSpecifikacijaTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ArtiklSpecifikacijaTipFilters : ArtiklSpecifikacijaTipFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaTipFilters class.
		/// </summary>
		public ArtiklSpecifikacijaTipFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ArtiklSpecifikacijaTipFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ArtiklSpecifikacijaTipFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ArtiklSpecifikacijaTipFilters
	
	#region ArtiklSpecifikacijaTipQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ArtiklSpecifikacijaTipParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ArtiklSpecifikacijaTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ArtiklSpecifikacijaTipQuery : ArtiklSpecifikacijaTipParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaTipQuery class.
		/// </summary>
		public ArtiklSpecifikacijaTipQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ArtiklSpecifikacijaTipQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ArtiklSpecifikacijaTipQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ArtiklSpecifikacijaTipQuery
		
	#region BlagajnaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Blagajna"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BlagajnaFilters : BlagajnaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BlagajnaFilters class.
		/// </summary>
		public BlagajnaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the BlagajnaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BlagajnaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BlagajnaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BlagajnaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BlagajnaFilters
	
	#region BlagajnaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="BlagajnaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Blagajna"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BlagajnaQuery : BlagajnaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BlagajnaQuery class.
		/// </summary>
		public BlagajnaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the BlagajnaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BlagajnaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BlagajnaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BlagajnaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BlagajnaQuery
		
	#region ArtiklStatusFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ArtiklStatus"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ArtiklStatusFilters : ArtiklStatusFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ArtiklStatusFilters class.
		/// </summary>
		public ArtiklStatusFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ArtiklStatusFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ArtiklStatusFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ArtiklStatusFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ArtiklStatusFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ArtiklStatusFilters
	
	#region ArtiklStatusQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ArtiklStatusParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ArtiklStatus"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ArtiklStatusQuery : ArtiklStatusParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ArtiklStatusQuery class.
		/// </summary>
		public ArtiklStatusQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ArtiklStatusQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ArtiklStatusQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ArtiklStatusQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ArtiklStatusQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ArtiklStatusQuery
		
	#region BlagajnaIzvjestajFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="BlagajnaIzvjestaj"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BlagajnaIzvjestajFilters : BlagajnaIzvjestajFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BlagajnaIzvjestajFilters class.
		/// </summary>
		public BlagajnaIzvjestajFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the BlagajnaIzvjestajFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BlagajnaIzvjestajFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BlagajnaIzvjestajFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BlagajnaIzvjestajFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BlagajnaIzvjestajFilters
	
	#region BlagajnaIzvjestajQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="BlagajnaIzvjestajParameterBuilder"/> class
	/// that is used exclusively with a <see cref="BlagajnaIzvjestaj"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BlagajnaIzvjestajQuery : BlagajnaIzvjestajParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BlagajnaIzvjestajQuery class.
		/// </summary>
		public BlagajnaIzvjestajQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the BlagajnaIzvjestajQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BlagajnaIzvjestajQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BlagajnaIzvjestajQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BlagajnaIzvjestajQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BlagajnaIzvjestajQuery
		
	#region BlagajnaStavkaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="BlagajnaStavka"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BlagajnaStavkaFilters : BlagajnaStavkaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BlagajnaStavkaFilters class.
		/// </summary>
		public BlagajnaStavkaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the BlagajnaStavkaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BlagajnaStavkaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BlagajnaStavkaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BlagajnaStavkaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BlagajnaStavkaFilters
	
	#region BlagajnaStavkaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="BlagajnaStavkaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="BlagajnaStavka"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BlagajnaStavkaQuery : BlagajnaStavkaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BlagajnaStavkaQuery class.
		/// </summary>
		public BlagajnaStavkaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the BlagajnaStavkaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BlagajnaStavkaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BlagajnaStavkaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BlagajnaStavkaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BlagajnaStavkaQuery
		
	#region BankaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Banka"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BankaFilters : BankaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BankaFilters class.
		/// </summary>
		public BankaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the BankaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BankaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BankaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BankaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BankaFilters
	
	#region BankaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="BankaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Banka"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BankaQuery : BankaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BankaQuery class.
		/// </summary>
		public BankaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the BankaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BankaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BankaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BankaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BankaQuery
		
	#region ArtiklSpecifikacijaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ArtiklSpecifikacija"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ArtiklSpecifikacijaFilters : ArtiklSpecifikacijaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaFilters class.
		/// </summary>
		public ArtiklSpecifikacijaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ArtiklSpecifikacijaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ArtiklSpecifikacijaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ArtiklSpecifikacijaFilters
	
	#region ArtiklSpecifikacijaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ArtiklSpecifikacijaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ArtiklSpecifikacija"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ArtiklSpecifikacijaQuery : ArtiklSpecifikacijaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaQuery class.
		/// </summary>
		public ArtiklSpecifikacijaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ArtiklSpecifikacijaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ArtiklSpecifikacijaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ArtiklSpecifikacijaQuery
		
	#region GrupaDjelatnikFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GrupaDjelatnik"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrupaDjelatnikFilters : GrupaDjelatnikFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikFilters class.
		/// </summary>
		public GrupaDjelatnikFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrupaDjelatnikFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrupaDjelatnikFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrupaDjelatnikFilters
	
	#region GrupaDjelatnikQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GrupaDjelatnikParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GrupaDjelatnik"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrupaDjelatnikQuery : GrupaDjelatnikParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikQuery class.
		/// </summary>
		public GrupaDjelatnikQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrupaDjelatnikQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrupaDjelatnikQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrupaDjelatnikQuery
		
	#region ArtiklSpecifikacijaStaticTableFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ArtiklSpecifikacijaStaticTable"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ArtiklSpecifikacijaStaticTableFilters : ArtiklSpecifikacijaStaticTableFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaStaticTableFilters class.
		/// </summary>
		public ArtiklSpecifikacijaStaticTableFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaStaticTableFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ArtiklSpecifikacijaStaticTableFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaStaticTableFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ArtiklSpecifikacijaStaticTableFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ArtiklSpecifikacijaStaticTableFilters
	
	#region ArtiklSpecifikacijaStaticTableQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ArtiklSpecifikacijaStaticTableParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ArtiklSpecifikacijaStaticTable"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ArtiklSpecifikacijaStaticTableQuery : ArtiklSpecifikacijaStaticTableParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaStaticTableQuery class.
		/// </summary>
		public ArtiklSpecifikacijaStaticTableQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaStaticTableQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ArtiklSpecifikacijaStaticTableQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ArtiklSpecifikacijaStaticTableQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ArtiklSpecifikacijaStaticTableQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ArtiklSpecifikacijaStaticTableQuery
		
	#region ArtiklVrijednostiFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ArtiklVrijednosti"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ArtiklVrijednostiFilters : ArtiklVrijednostiFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ArtiklVrijednostiFilters class.
		/// </summary>
		public ArtiklVrijednostiFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ArtiklVrijednostiFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ArtiklVrijednostiFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ArtiklVrijednostiFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ArtiklVrijednostiFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ArtiklVrijednostiFilters
	
	#region ArtiklVrijednostiQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ArtiklVrijednostiParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ArtiklVrijednosti"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ArtiklVrijednostiQuery : ArtiklVrijednostiParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ArtiklVrijednostiQuery class.
		/// </summary>
		public ArtiklVrijednostiQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ArtiklVrijednostiQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ArtiklVrijednostiQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ArtiklVrijednostiQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ArtiklVrijednostiQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ArtiklVrijednostiQuery
		
	#region NetoBrutoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NetoBruto"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NetoBrutoFilters : NetoBrutoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NetoBrutoFilters class.
		/// </summary>
		public NetoBrutoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NetoBrutoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NetoBrutoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NetoBrutoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NetoBrutoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NetoBrutoFilters
	
	#region NetoBrutoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NetoBrutoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NetoBruto"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NetoBrutoQuery : NetoBrutoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NetoBrutoQuery class.
		/// </summary>
		public NetoBrutoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NetoBrutoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NetoBrutoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NetoBrutoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NetoBrutoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NetoBrutoQuery
		
	#region MjestoTipFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="MjestoTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MjestoTipFilters : MjestoTipFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MjestoTipFilters class.
		/// </summary>
		public MjestoTipFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MjestoTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MjestoTipFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MjestoTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MjestoTipFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MjestoTipFilters
	
	#region MjestoTipQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MjestoTipParameterBuilder"/> class
	/// that is used exclusively with a <see cref="MjestoTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MjestoTipQuery : MjestoTipParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MjestoTipQuery class.
		/// </summary>
		public MjestoTipQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MjestoTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MjestoTipQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MjestoTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MjestoTipQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MjestoTipQuery
		
	#region NAppUpdateFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NAppUpdate"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NAppUpdateFilters : NAppUpdateFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NAppUpdateFilters class.
		/// </summary>
		public NAppUpdateFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NAppUpdateFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NAppUpdateFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NAppUpdateFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NAppUpdateFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NAppUpdateFilters
	
	#region NAppUpdateQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NAppUpdateParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NAppUpdate"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NAppUpdateQuery : NAppUpdateParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NAppUpdateQuery class.
		/// </summary>
		public NAppUpdateQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NAppUpdateQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NAppUpdateQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NAppUpdateQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NAppUpdateQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NAppUpdateQuery
		
	#region ObracunFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Obracun"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunFilters : ObracunFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunFilters class.
		/// </summary>
		public ObracunFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunFilters
	
	#region ObracunQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ObracunParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Obracun"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunQuery : ObracunParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunQuery class.
		/// </summary>
		public ObracunQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunQuery
		
	#region NacinTransportaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NacinTransporta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NacinTransportaFilters : NacinTransportaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NacinTransportaFilters class.
		/// </summary>
		public NacinTransportaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NacinTransportaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NacinTransportaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NacinTransportaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NacinTransportaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NacinTransportaFilters
	
	#region NacinTransportaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NacinTransportaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NacinTransporta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NacinTransportaQuery : NacinTransportaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NacinTransportaQuery class.
		/// </summary>
		public NacinTransportaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NacinTransportaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NacinTransportaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NacinTransportaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NacinTransportaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NacinTransportaQuery
		
	#region GrupaDjelatnikParametraFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GrupaDjelatnikParametra"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrupaDjelatnikParametraFilters : GrupaDjelatnikParametraFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikParametraFilters class.
		/// </summary>
		public GrupaDjelatnikParametraFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikParametraFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrupaDjelatnikParametraFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikParametraFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrupaDjelatnikParametraFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrupaDjelatnikParametraFilters
	
	#region GrupaDjelatnikParametraQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GrupaDjelatnikParametraParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GrupaDjelatnikParametra"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrupaDjelatnikParametraQuery : GrupaDjelatnikParametraParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikParametraQuery class.
		/// </summary>
		public GrupaDjelatnikParametraQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikParametraQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrupaDjelatnikParametraQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikParametraQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrupaDjelatnikParametraQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrupaDjelatnikParametraQuery
		
	#region KontoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Konto"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KontoFilters : KontoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KontoFilters class.
		/// </summary>
		public KontoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the KontoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KontoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KontoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KontoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KontoFilters
	
	#region KontoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="KontoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Konto"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KontoQuery : KontoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KontoQuery class.
		/// </summary>
		public KontoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the KontoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KontoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KontoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KontoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KontoQuery
		
	#region ObracunKamataFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ObracunKamata"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunKamataFilters : ObracunKamataFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunKamataFilters class.
		/// </summary>
		public ObracunKamataFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunKamataFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunKamataFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunKamataFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunKamataFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunKamataFilters
	
	#region ObracunKamataQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ObracunKamataParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ObracunKamata"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunKamataQuery : ObracunKamataParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunKamataQuery class.
		/// </summary>
		public ObracunKamataQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunKamataQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunKamataQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunKamataQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunKamataQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunKamataQuery
		
	#region NacinPlacanjaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NacinPlacanja"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NacinPlacanjaFilters : NacinPlacanjaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NacinPlacanjaFilters class.
		/// </summary>
		public NacinPlacanjaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NacinPlacanjaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NacinPlacanjaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NacinPlacanjaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NacinPlacanjaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NacinPlacanjaFilters
	
	#region NacinPlacanjaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NacinPlacanjaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NacinPlacanja"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NacinPlacanjaQuery : NacinPlacanjaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NacinPlacanjaQuery class.
		/// </summary>
		public NacinPlacanjaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NacinPlacanjaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NacinPlacanjaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NacinPlacanjaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NacinPlacanjaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NacinPlacanjaQuery
		
	#region ObracunOsobaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ObracunOsoba"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunOsobaFilters : ObracunOsobaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaFilters class.
		/// </summary>
		public ObracunOsobaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunOsobaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunOsobaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunOsobaFilters
	
	#region ObracunOsobaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ObracunOsobaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ObracunOsoba"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunOsobaQuery : ObracunOsobaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaQuery class.
		/// </summary>
		public ObracunOsobaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunOsobaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunOsobaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunOsobaQuery
		
	#region ObracunKamataProknjizenFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ObracunKamataProknjizen"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunKamataProknjizenFilters : ObracunKamataProknjizenFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunKamataProknjizenFilters class.
		/// </summary>
		public ObracunKamataProknjizenFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunKamataProknjizenFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunKamataProknjizenFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunKamataProknjizenFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunKamataProknjizenFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunKamataProknjizenFilters
	
	#region ObracunKamataProknjizenQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ObracunKamataProknjizenParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ObracunKamataProknjizen"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunKamataProknjizenQuery : ObracunKamataProknjizenParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunKamataProknjizenQuery class.
		/// </summary>
		public ObracunKamataProknjizenQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunKamataProknjizenQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunKamataProknjizenQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunKamataProknjizenQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunKamataProknjizenQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunKamataProknjizenQuery
		
	#region IspisFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Ispis"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class IspisFilters : IspisFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the IspisFilters class.
		/// </summary>
		public IspisFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the IspisFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public IspisFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the IspisFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public IspisFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion IspisFilters
	
	#region IspisQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="IspisParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Ispis"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class IspisQuery : IspisParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the IspisQuery class.
		/// </summary>
		public IspisQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the IspisQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public IspisQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the IspisQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public IspisQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion IspisQuery
		
	#region ObracunOsobaObustavaNaknadaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ObracunOsobaObustavaNaknada"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunOsobaObustavaNaknadaFilters : ObracunOsobaObustavaNaknadaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaObustavaNaknadaFilters class.
		/// </summary>
		public ObracunOsobaObustavaNaknadaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaObustavaNaknadaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunOsobaObustavaNaknadaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaObustavaNaknadaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunOsobaObustavaNaknadaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunOsobaObustavaNaknadaFilters
	
	#region ObracunOsobaObustavaNaknadaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ObracunOsobaObustavaNaknadaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ObracunOsobaObustavaNaknada"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunOsobaObustavaNaknadaQuery : ObracunOsobaObustavaNaknadaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaObustavaNaknadaQuery class.
		/// </summary>
		public ObracunOsobaObustavaNaknadaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaObustavaNaknadaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunOsobaObustavaNaknadaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaObustavaNaknadaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunOsobaObustavaNaknadaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunOsobaObustavaNaknadaQuery
		
	#region ObracunKamataShemaKnjizFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ObracunKamataShemaKnjiz"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunKamataShemaKnjizFilters : ObracunKamataShemaKnjizFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunKamataShemaKnjizFilters class.
		/// </summary>
		public ObracunKamataShemaKnjizFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunKamataShemaKnjizFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunKamataShemaKnjizFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunKamataShemaKnjizFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunKamataShemaKnjizFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunKamataShemaKnjizFilters
	
	#region ObracunKamataShemaKnjizQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ObracunKamataShemaKnjizParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ObracunKamataShemaKnjiz"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunKamataShemaKnjizQuery : ObracunKamataShemaKnjizParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunKamataShemaKnjizQuery class.
		/// </summary>
		public ObracunKamataShemaKnjizQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunKamataShemaKnjizQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunKamataShemaKnjizQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunKamataShemaKnjizQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunKamataShemaKnjizQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunKamataShemaKnjizQuery
		
	#region IspisKolonaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="IspisKolona"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class IspisKolonaFilters : IspisKolonaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the IspisKolonaFilters class.
		/// </summary>
		public IspisKolonaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the IspisKolonaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public IspisKolonaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the IspisKolonaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public IspisKolonaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion IspisKolonaFilters
	
	#region IspisKolonaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="IspisKolonaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="IspisKolona"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class IspisKolonaQuery : IspisKolonaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the IspisKolonaQuery class.
		/// </summary>
		public IspisKolonaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the IspisKolonaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public IspisKolonaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the IspisKolonaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public IspisKolonaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion IspisKolonaQuery
		
	#region ObracunOsobaPoreznaOlaksicaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ObracunOsobaPoreznaOlaksica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunOsobaPoreznaOlaksicaFilters : ObracunOsobaPoreznaOlaksicaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaPoreznaOlaksicaFilters class.
		/// </summary>
		public ObracunOsobaPoreznaOlaksicaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaPoreznaOlaksicaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunOsobaPoreznaOlaksicaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaPoreznaOlaksicaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunOsobaPoreznaOlaksicaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunOsobaPoreznaOlaksicaFilters
	
	#region ObracunOsobaPoreznaOlaksicaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ObracunOsobaPoreznaOlaksicaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ObracunOsobaPoreznaOlaksica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunOsobaPoreznaOlaksicaQuery : ObracunOsobaPoreznaOlaksicaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaPoreznaOlaksicaQuery class.
		/// </summary>
		public ObracunOsobaPoreznaOlaksicaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaPoreznaOlaksicaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunOsobaPoreznaOlaksicaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunOsobaPoreznaOlaksicaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunOsobaPoreznaOlaksicaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunOsobaPoreznaOlaksicaQuery
		
	#region ObracunKamataStavkeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ObracunKamataStavke"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunKamataStavkeFilters : ObracunKamataStavkeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunKamataStavkeFilters class.
		/// </summary>
		public ObracunKamataStavkeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunKamataStavkeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunKamataStavkeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunKamataStavkeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunKamataStavkeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunKamataStavkeFilters
	
	#region ObracunKamataStavkeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ObracunKamataStavkeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ObracunKamataStavke"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ObracunKamataStavkeQuery : ObracunKamataStavkeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ObracunKamataStavkeQuery class.
		/// </summary>
		public ObracunKamataStavkeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ObracunKamataStavkeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ObracunKamataStavkeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ObracunKamataStavkeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ObracunKamataStavkeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ObracunKamataStavkeQuery
		
	#region GrupaDozvoleFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GrupaDozvole"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrupaDozvoleFilters : GrupaDozvoleFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrupaDozvoleFilters class.
		/// </summary>
		public GrupaDozvoleFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrupaDozvoleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrupaDozvoleFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrupaDozvoleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrupaDozvoleFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrupaDozvoleFilters
	
	#region GrupaDozvoleQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GrupaDozvoleParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GrupaDozvole"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrupaDozvoleQuery : GrupaDozvoleParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrupaDozvoleQuery class.
		/// </summary>
		public GrupaDozvoleQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrupaDozvoleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrupaDozvoleQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrupaDozvoleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrupaDozvoleQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrupaDozvoleQuery
		
	#region GrupaDjelatnikReportFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GrupaDjelatnikReport"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrupaDjelatnikReportFilters : GrupaDjelatnikReportFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikReportFilters class.
		/// </summary>
		public GrupaDjelatnikReportFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikReportFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrupaDjelatnikReportFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikReportFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrupaDjelatnikReportFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrupaDjelatnikReportFilters
	
	#region GrupaDjelatnikReportQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GrupaDjelatnikReportParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GrupaDjelatnikReport"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrupaDjelatnikReportQuery : GrupaDjelatnikReportParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikReportQuery class.
		/// </summary>
		public GrupaDjelatnikReportQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikReportQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrupaDjelatnikReportQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrupaDjelatnikReportQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrupaDjelatnikReportQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrupaDjelatnikReportQuery
		
	#region MjestoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Mjesto"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MjestoFilters : MjestoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MjestoFilters class.
		/// </summary>
		public MjestoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MjestoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MjestoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MjestoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MjestoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MjestoFilters
	
	#region MjestoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MjestoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Mjesto"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MjestoQuery : MjestoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MjestoQuery class.
		/// </summary>
		public MjestoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MjestoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MjestoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MjestoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MjestoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MjestoQuery
		
	#region InvaliditetFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Invaliditet"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class InvaliditetFilters : InvaliditetFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the InvaliditetFilters class.
		/// </summary>
		public InvaliditetFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the InvaliditetFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public InvaliditetFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the InvaliditetFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public InvaliditetFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion InvaliditetFilters
	
	#region InvaliditetQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="InvaliditetParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Invaliditet"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class InvaliditetQuery : InvaliditetParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the InvaliditetQuery class.
		/// </summary>
		public InvaliditetQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the InvaliditetQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public InvaliditetQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the InvaliditetQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public InvaliditetQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion InvaliditetQuery
		
	#region KlijentFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Klijent"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KlijentFilters : KlijentFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KlijentFilters class.
		/// </summary>
		public KlijentFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the KlijentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KlijentFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KlijentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KlijentFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KlijentFilters
	
	#region KlijentQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="KlijentParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Klijent"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KlijentQuery : KlijentParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KlijentQuery class.
		/// </summary>
		public KlijentQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the KlijentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KlijentQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KlijentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KlijentQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KlijentQuery
		
	#region KlijentTipFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="KlijentTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KlijentTipFilters : KlijentTipFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KlijentTipFilters class.
		/// </summary>
		public KlijentTipFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the KlijentTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KlijentTipFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KlijentTipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KlijentTipFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KlijentTipFilters
	
	#region KlijentTipQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="KlijentTipParameterBuilder"/> class
	/// that is used exclusively with a <see cref="KlijentTip"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KlijentTipQuery : KlijentTipParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KlijentTipQuery class.
		/// </summary>
		public KlijentTipQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the KlijentTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KlijentTipQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KlijentTipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KlijentTipQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KlijentTipQuery
		
	#region KnjizenjeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Knjizenje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KnjizenjeFilters : KnjizenjeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KnjizenjeFilters class.
		/// </summary>
		public KnjizenjeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the KnjizenjeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KnjizenjeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KnjizenjeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KnjizenjeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KnjizenjeFilters
	
	#region KnjizenjeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="KnjizenjeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Knjizenje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KnjizenjeQuery : KnjizenjeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KnjizenjeQuery class.
		/// </summary>
		public KnjizenjeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the KnjizenjeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KnjizenjeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KnjizenjeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KnjizenjeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KnjizenjeQuery
		
	#region KnjizenjeStavkaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="KnjizenjeStavka"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KnjizenjeStavkaFilters : KnjizenjeStavkaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KnjizenjeStavkaFilters class.
		/// </summary>
		public KnjizenjeStavkaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the KnjizenjeStavkaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KnjizenjeStavkaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KnjizenjeStavkaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KnjizenjeStavkaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KnjizenjeStavkaFilters
	
	#region KnjizenjeStavkaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="KnjizenjeStavkaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="KnjizenjeStavka"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KnjizenjeStavkaQuery : KnjizenjeStavkaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KnjizenjeStavkaQuery class.
		/// </summary>
		public KnjizenjeStavkaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the KnjizenjeStavkaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KnjizenjeStavkaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KnjizenjeStavkaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KnjizenjeStavkaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KnjizenjeStavkaQuery
		
	#region KlijentNapomenaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="KlijentNapomena"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KlijentNapomenaFilters : KlijentNapomenaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KlijentNapomenaFilters class.
		/// </summary>
		public KlijentNapomenaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the KlijentNapomenaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KlijentNapomenaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KlijentNapomenaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KlijentNapomenaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KlijentNapomenaFilters
	
	#region KlijentNapomenaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="KlijentNapomenaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="KlijentNapomena"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KlijentNapomenaQuery : KlijentNapomenaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KlijentNapomenaQuery class.
		/// </summary>
		public KlijentNapomenaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the KlijentNapomenaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KlijentNapomenaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KlijentNapomenaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KlijentNapomenaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KlijentNapomenaQuery
		
	#region IzvadakFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Izvadak"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class IzvadakFilters : IzvadakFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the IzvadakFilters class.
		/// </summary>
		public IzvadakFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the IzvadakFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public IzvadakFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the IzvadakFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public IzvadakFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion IzvadakFilters
	
	#region IzvadakQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="IzvadakParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Izvadak"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class IzvadakQuery : IzvadakParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the IzvadakQuery class.
		/// </summary>
		public IzvadakQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the IzvadakQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public IzvadakQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the IzvadakQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public IzvadakQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion IzvadakQuery
		
	#region KlijentOsobaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="KlijentOsoba"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KlijentOsobaFilters : KlijentOsobaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KlijentOsobaFilters class.
		/// </summary>
		public KlijentOsobaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the KlijentOsobaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KlijentOsobaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KlijentOsobaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KlijentOsobaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KlijentOsobaFilters
	
	#region KlijentOsobaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="KlijentOsobaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="KlijentOsoba"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KlijentOsobaQuery : KlijentOsobaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KlijentOsobaQuery class.
		/// </summary>
		public KlijentOsobaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the KlijentOsobaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KlijentOsobaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KlijentOsobaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KlijentOsobaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KlijentOsobaQuery
		
	#region KlijentBankovniRacunFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="KlijentBankovniRacun"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KlijentBankovniRacunFilters : KlijentBankovniRacunFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KlijentBankovniRacunFilters class.
		/// </summary>
		public KlijentBankovniRacunFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the KlijentBankovniRacunFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KlijentBankovniRacunFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KlijentBankovniRacunFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KlijentBankovniRacunFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KlijentBankovniRacunFilters
	
	#region KlijentBankovniRacunQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="KlijentBankovniRacunParameterBuilder"/> class
	/// that is used exclusively with a <see cref="KlijentBankovniRacun"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KlijentBankovniRacunQuery : KlijentBankovniRacunParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KlijentBankovniRacunQuery class.
		/// </summary>
		public KlijentBankovniRacunQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the KlijentBankovniRacunQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KlijentBankovniRacunQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KlijentBankovniRacunQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KlijentBankovniRacunQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KlijentBankovniRacunQuery
		
	#region KontoKolonaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="KontoKolona"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KontoKolonaFilters : KontoKolonaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KontoKolonaFilters class.
		/// </summary>
		public KontoKolonaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the KontoKolonaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KontoKolonaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KontoKolonaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KontoKolonaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KontoKolonaFilters
	
	#region KontoKolonaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="KontoKolonaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="KontoKolona"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class KontoKolonaQuery : KontoKolonaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the KontoKolonaQuery class.
		/// </summary>
		public KontoKolonaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the KontoKolonaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public KontoKolonaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the KontoKolonaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public KontoKolonaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion KontoKolonaQuery
		
	#region ZatvaranjeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Zatvaranje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ZatvaranjeFilters : ZatvaranjeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ZatvaranjeFilters class.
		/// </summary>
		public ZatvaranjeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ZatvaranjeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ZatvaranjeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ZatvaranjeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ZatvaranjeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ZatvaranjeFilters
	
	#region ZatvaranjeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ZatvaranjeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Zatvaranje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ZatvaranjeQuery : ZatvaranjeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ZatvaranjeQuery class.
		/// </summary>
		public ZatvaranjeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ZatvaranjeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ZatvaranjeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ZatvaranjeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ZatvaranjeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ZatvaranjeQuery
		
	#region VwArtiklKategorijaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwArtiklKategorija"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwArtiklKategorijaFilters : VwArtiklKategorijaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwArtiklKategorijaFilters class.
		/// </summary>
		public VwArtiklKategorijaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwArtiklKategorijaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwArtiklKategorijaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwArtiklKategorijaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwArtiklKategorijaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwArtiklKategorijaFilters
	
	#region VwArtiklKategorijaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwArtiklKategorijaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwArtiklKategorija"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwArtiklKategorijaQuery : VwArtiklKategorijaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwArtiklKategorijaQuery class.
		/// </summary>
		public VwArtiklKategorijaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwArtiklKategorijaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwArtiklKategorijaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwArtiklKategorijaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwArtiklKategorijaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwArtiklKategorijaQuery
		
	#region VwArtiklStanjeuSkladistuFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwArtiklStanjeuSkladistu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwArtiklStanjeuSkladistuFilters : VwArtiklStanjeuSkladistuFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwArtiklStanjeuSkladistuFilters class.
		/// </summary>
		public VwArtiklStanjeuSkladistuFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwArtiklStanjeuSkladistuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwArtiklStanjeuSkladistuFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwArtiklStanjeuSkladistuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwArtiklStanjeuSkladistuFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwArtiklStanjeuSkladistuFilters
	
	#region VwArtiklStanjeuSkladistuQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwArtiklStanjeuSkladistuParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwArtiklStanjeuSkladistu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwArtiklStanjeuSkladistuQuery : VwArtiklStanjeuSkladistuParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwArtiklStanjeuSkladistuQuery class.
		/// </summary>
		public VwArtiklStanjeuSkladistuQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwArtiklStanjeuSkladistuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwArtiklStanjeuSkladistuQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwArtiklStanjeuSkladistuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwArtiklStanjeuSkladistuQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwArtiklStanjeuSkladistuQuery
		
	#region VwArtiklStanjeVPCFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwArtiklStanjeVPC"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwArtiklStanjeVPCFilters : VwArtiklStanjeVPCFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwArtiklStanjeVPCFilters class.
		/// </summary>
		public VwArtiklStanjeVPCFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwArtiklStanjeVPCFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwArtiklStanjeVPCFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwArtiklStanjeVPCFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwArtiklStanjeVPCFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwArtiklStanjeVPCFilters
	
	#region VwArtiklStanjeVPCQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwArtiklStanjeVPCParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwArtiklStanjeVPC"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwArtiklStanjeVPCQuery : VwArtiklStanjeVPCParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwArtiklStanjeVPCQuery class.
		/// </summary>
		public VwArtiklStanjeVPCQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwArtiklStanjeVPCQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwArtiklStanjeVPCQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwArtiklStanjeVPCQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwArtiklStanjeVPCQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwArtiklStanjeVPCQuery
		
	#region VwArtiklTraziFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwArtiklTrazi"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwArtiklTraziFilters : VwArtiklTraziFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwArtiklTraziFilters class.
		/// </summary>
		public VwArtiklTraziFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwArtiklTraziFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwArtiklTraziFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwArtiklTraziFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwArtiklTraziFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwArtiklTraziFilters
	
	#region VwArtiklTraziQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwArtiklTraziParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwArtiklTrazi"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwArtiklTraziQuery : VwArtiklTraziParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwArtiklTraziQuery class.
		/// </summary>
		public VwArtiklTraziQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwArtiklTraziQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwArtiklTraziQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwArtiklTraziQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwArtiklTraziQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwArtiklTraziQuery
		
	#region VwBankaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwBanka"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwBankaFilters : VwBankaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwBankaFilters class.
		/// </summary>
		public VwBankaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwBankaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwBankaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwBankaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwBankaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwBankaFilters
	
	#region VwBankaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwBankaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwBanka"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwBankaQuery : VwBankaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwBankaQuery class.
		/// </summary>
		public VwBankaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwBankaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwBankaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwBankaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwBankaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwBankaQuery
		
	#region VwBlagajnaIzvjestajSaldoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwBlagajnaIzvjestajSaldo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwBlagajnaIzvjestajSaldoFilters : VwBlagajnaIzvjestajSaldoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaIzvjestajSaldoFilters class.
		/// </summary>
		public VwBlagajnaIzvjestajSaldoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaIzvjestajSaldoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwBlagajnaIzvjestajSaldoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaIzvjestajSaldoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwBlagajnaIzvjestajSaldoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwBlagajnaIzvjestajSaldoFilters
	
	#region VwBlagajnaIzvjestajSaldoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwBlagajnaIzvjestajSaldoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwBlagajnaIzvjestajSaldo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwBlagajnaIzvjestajSaldoQuery : VwBlagajnaIzvjestajSaldoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaIzvjestajSaldoQuery class.
		/// </summary>
		public VwBlagajnaIzvjestajSaldoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaIzvjestajSaldoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwBlagajnaIzvjestajSaldoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaIzvjestajSaldoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwBlagajnaIzvjestajSaldoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwBlagajnaIzvjestajSaldoQuery
		
	#region VwBlagajnaSaldoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwBlagajnaSaldo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwBlagajnaSaldoFilters : VwBlagajnaSaldoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaSaldoFilters class.
		/// </summary>
		public VwBlagajnaSaldoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaSaldoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwBlagajnaSaldoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaSaldoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwBlagajnaSaldoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwBlagajnaSaldoFilters
	
	#region VwBlagajnaSaldoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwBlagajnaSaldoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwBlagajnaSaldo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwBlagajnaSaldoQuery : VwBlagajnaSaldoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaSaldoQuery class.
		/// </summary>
		public VwBlagajnaSaldoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaSaldoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwBlagajnaSaldoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaSaldoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwBlagajnaSaldoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwBlagajnaSaldoQuery
		
	#region VwBlagajnaStavkaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwBlagajnaStavka"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwBlagajnaStavkaFilters : VwBlagajnaStavkaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaStavkaFilters class.
		/// </summary>
		public VwBlagajnaStavkaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaStavkaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwBlagajnaStavkaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaStavkaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwBlagajnaStavkaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwBlagajnaStavkaFilters
	
	#region VwBlagajnaStavkaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwBlagajnaStavkaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwBlagajnaStavka"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwBlagajnaStavkaQuery : VwBlagajnaStavkaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaStavkaQuery class.
		/// </summary>
		public VwBlagajnaStavkaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaStavkaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwBlagajnaStavkaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwBlagajnaStavkaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwBlagajnaStavkaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwBlagajnaStavkaQuery
		
	#region VwDefParametriDjelatnikaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwDefParametriDjelatnika"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwDefParametriDjelatnikaFilters : VwDefParametriDjelatnikaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwDefParametriDjelatnikaFilters class.
		/// </summary>
		public VwDefParametriDjelatnikaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwDefParametriDjelatnikaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwDefParametriDjelatnikaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwDefParametriDjelatnikaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwDefParametriDjelatnikaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwDefParametriDjelatnikaFilters
	
	#region VwDefParametriDjelatnikaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwDefParametriDjelatnikaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwDefParametriDjelatnika"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwDefParametriDjelatnikaQuery : VwDefParametriDjelatnikaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwDefParametriDjelatnikaQuery class.
		/// </summary>
		public VwDefParametriDjelatnikaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwDefParametriDjelatnikaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwDefParametriDjelatnikaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwDefParametriDjelatnikaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwDefParametriDjelatnikaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwDefParametriDjelatnikaQuery
		
	#region VwDokumentFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwDokument"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwDokumentFilters : VwDokumentFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwDokumentFilters class.
		/// </summary>
		public VwDokumentFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwDokumentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwDokumentFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwDokumentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwDokumentFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwDokumentFilters
	
	#region VwDokumentQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwDokumentParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwDokument"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwDokumentQuery : VwDokumentParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwDokumentQuery class.
		/// </summary>
		public VwDokumentQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwDokumentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwDokumentQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwDokumentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwDokumentQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwDokumentQuery
		
	#region VwDozvoleGrupeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwDozvoleGrupe"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwDozvoleGrupeFilters : VwDozvoleGrupeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwDozvoleGrupeFilters class.
		/// </summary>
		public VwDozvoleGrupeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwDozvoleGrupeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwDozvoleGrupeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwDozvoleGrupeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwDozvoleGrupeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwDozvoleGrupeFilters
	
	#region VwDozvoleGrupeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwDozvoleGrupeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwDozvoleGrupe"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwDozvoleGrupeQuery : VwDozvoleGrupeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwDozvoleGrupeQuery class.
		/// </summary>
		public VwDozvoleGrupeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwDozvoleGrupeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwDozvoleGrupeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwDozvoleGrupeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwDozvoleGrupeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwDozvoleGrupeQuery
		
	#region VwDozvoleOrganizacijeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwDozvoleOrganizacije"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwDozvoleOrganizacijeFilters : VwDozvoleOrganizacijeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwDozvoleOrganizacijeFilters class.
		/// </summary>
		public VwDozvoleOrganizacijeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwDozvoleOrganizacijeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwDozvoleOrganizacijeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwDozvoleOrganizacijeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwDozvoleOrganizacijeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwDozvoleOrganizacijeFilters
	
	#region VwDozvoleOrganizacijeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwDozvoleOrganizacijeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwDozvoleOrganizacije"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwDozvoleOrganizacijeQuery : VwDozvoleOrganizacijeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwDozvoleOrganizacijeQuery class.
		/// </summary>
		public VwDozvoleOrganizacijeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwDozvoleOrganizacijeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwDozvoleOrganizacijeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwDozvoleOrganizacijeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwDozvoleOrganizacijeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwDozvoleOrganizacijeQuery
		
	#region VwIspisFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwIspis"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwIspisFilters : VwIspisFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwIspisFilters class.
		/// </summary>
		public VwIspisFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwIspisFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwIspisFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwIspisFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwIspisFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwIspisFilters
	
	#region VwIspisQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwIspisParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwIspis"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwIspisQuery : VwIspisParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwIspisQuery class.
		/// </summary>
		public VwIspisQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwIspisQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwIspisQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwIspisQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwIspisQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwIspisQuery
		
	#region VwIzvadakFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwIzvadak"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwIzvadakFilters : VwIzvadakFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwIzvadakFilters class.
		/// </summary>
		public VwIzvadakFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwIzvadakFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwIzvadakFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwIzvadakFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwIzvadakFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwIzvadakFilters
	
	#region VwIzvadakQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwIzvadakParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwIzvadak"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwIzvadakQuery : VwIzvadakParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwIzvadakQuery class.
		/// </summary>
		public VwIzvadakQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwIzvadakQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwIzvadakQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwIzvadakQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwIzvadakQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwIzvadakQuery
		
	#region VwKlijentFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwKlijent"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwKlijentFilters : VwKlijentFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwKlijentFilters class.
		/// </summary>
		public VwKlijentFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwKlijentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwKlijentFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwKlijentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwKlijentFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwKlijentFilters
	
	#region VwKlijentQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwKlijentParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwKlijent"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwKlijentQuery : VwKlijentParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwKlijentQuery class.
		/// </summary>
		public VwKlijentQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwKlijentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwKlijentQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwKlijentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwKlijentQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwKlijentQuery
		
	#region VwKnjizenjeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwKnjizenje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwKnjizenjeFilters : VwKnjizenjeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwKnjizenjeFilters class.
		/// </summary>
		public VwKnjizenjeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwKnjizenjeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwKnjizenjeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwKnjizenjeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwKnjizenjeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwKnjizenjeFilters
	
	#region VwKnjizenjeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwKnjizenjeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwKnjizenje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwKnjizenjeQuery : VwKnjizenjeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwKnjizenjeQuery class.
		/// </summary>
		public VwKnjizenjeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwKnjizenjeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwKnjizenjeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwKnjizenjeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwKnjizenjeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwKnjizenjeQuery
		
	#region VwKnjizenjeIspisFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwKnjizenjeIspis"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwKnjizenjeIspisFilters : VwKnjizenjeIspisFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwKnjizenjeIspisFilters class.
		/// </summary>
		public VwKnjizenjeIspisFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwKnjizenjeIspisFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwKnjizenjeIspisFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwKnjizenjeIspisFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwKnjizenjeIspisFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwKnjizenjeIspisFilters
	
	#region VwKnjizenjeIspisQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwKnjizenjeIspisParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwKnjizenjeIspis"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwKnjizenjeIspisQuery : VwKnjizenjeIspisParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwKnjizenjeIspisQuery class.
		/// </summary>
		public VwKnjizenjeIspisQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwKnjizenjeIspisQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwKnjizenjeIspisQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwKnjizenjeIspisQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwKnjizenjeIspisQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwKnjizenjeIspisQuery
		
	#region VwKontoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwKonto"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwKontoFilters : VwKontoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwKontoFilters class.
		/// </summary>
		public VwKontoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwKontoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwKontoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwKontoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwKontoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwKontoFilters
	
	#region VwKontoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwKontoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwKonto"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwKontoQuery : VwKontoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwKontoQuery class.
		/// </summary>
		public VwKontoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwKontoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwKontoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwKontoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwKontoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwKontoQuery
		
	#region VwKopiranjeDokumentaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwKopiranjeDokumenta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwKopiranjeDokumentaFilters : VwKopiranjeDokumentaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwKopiranjeDokumentaFilters class.
		/// </summary>
		public VwKopiranjeDokumentaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwKopiranjeDokumentaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwKopiranjeDokumentaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwKopiranjeDokumentaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwKopiranjeDokumentaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwKopiranjeDokumentaFilters
	
	#region VwKopiranjeDokumentaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwKopiranjeDokumentaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwKopiranjeDokumenta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwKopiranjeDokumentaQuery : VwKopiranjeDokumentaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwKopiranjeDokumentaQuery class.
		/// </summary>
		public VwKopiranjeDokumentaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwKopiranjeDokumentaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwKopiranjeDokumentaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwKopiranjeDokumentaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwKopiranjeDokumentaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwKopiranjeDokumentaQuery
		
	#region VwNc_Po_DobavljacuFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwNc_Po_Dobavljacu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwNc_Po_DobavljacuFilters : VwNc_Po_DobavljacuFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwNc_Po_DobavljacuFilters class.
		/// </summary>
		public VwNc_Po_DobavljacuFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwNc_Po_DobavljacuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwNc_Po_DobavljacuFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwNc_Po_DobavljacuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwNc_Po_DobavljacuFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwNc_Po_DobavljacuFilters
	
	#region VwNc_Po_DobavljacuQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwNc_Po_DobavljacuParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwNc_Po_Dobavljacu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwNc_Po_DobavljacuQuery : VwNc_Po_DobavljacuParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwNc_Po_DobavljacuQuery class.
		/// </summary>
		public VwNc_Po_DobavljacuQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwNc_Po_DobavljacuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwNc_Po_DobavljacuQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwNc_Po_DobavljacuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwNc_Po_DobavljacuQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwNc_Po_DobavljacuQuery
		
	#region VwObracunDefaultVrijednostiFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwObracunDefaultVrijednosti"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunDefaultVrijednostiFilters : VwObracunDefaultVrijednostiFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunDefaultVrijednostiFilters class.
		/// </summary>
		public VwObracunDefaultVrijednostiFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunDefaultVrijednostiFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunDefaultVrijednostiFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunDefaultVrijednostiFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunDefaultVrijednostiFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunDefaultVrijednostiFilters
	
	#region VwObracunDefaultVrijednostiQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwObracunDefaultVrijednostiParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwObracunDefaultVrijednosti"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunDefaultVrijednostiQuery : VwObracunDefaultVrijednostiParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunDefaultVrijednostiQuery class.
		/// </summary>
		public VwObracunDefaultVrijednostiQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunDefaultVrijednostiQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunDefaultVrijednostiQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunDefaultVrijednostiQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunDefaultVrijednostiQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunDefaultVrijednostiQuery
		
	#region VwObracunKamataFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwObracunKamata"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunKamataFilters : VwObracunKamataFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunKamataFilters class.
		/// </summary>
		public VwObracunKamataFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunKamataFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunKamataFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunKamataFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunKamataFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunKamataFilters
	
	#region VwObracunKamataQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwObracunKamataParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwObracunKamata"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunKamataQuery : VwObracunKamataParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunKamataQuery class.
		/// </summary>
		public VwObracunKamataQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunKamataQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunKamataQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunKamataQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunKamataQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunKamataQuery
		
	#region VwObracunKamataTraziFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwObracunKamataTrazi"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunKamataTraziFilters : VwObracunKamataTraziFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunKamataTraziFilters class.
		/// </summary>
		public VwObracunKamataTraziFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunKamataTraziFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunKamataTraziFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunKamataTraziFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunKamataTraziFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunKamataTraziFilters
	
	#region VwObracunKamataTraziQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwObracunKamataTraziParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwObracunKamataTrazi"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunKamataTraziQuery : VwObracunKamataTraziParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunKamataTraziQuery class.
		/// </summary>
		public VwObracunKamataTraziQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunKamataTraziQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunKamataTraziQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunKamataTraziQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunKamataTraziQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunKamataTraziQuery
		
	#region VwObracunSpecifikacijaPoBankamaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwObracunSpecifikacijaPoBankama"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunSpecifikacijaPoBankamaFilters : VwObracunSpecifikacijaPoBankamaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunSpecifikacijaPoBankamaFilters class.
		/// </summary>
		public VwObracunSpecifikacijaPoBankamaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunSpecifikacijaPoBankamaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunSpecifikacijaPoBankamaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunSpecifikacijaPoBankamaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunSpecifikacijaPoBankamaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunSpecifikacijaPoBankamaFilters
	
	#region VwObracunSpecifikacijaPoBankamaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwObracunSpecifikacijaPoBankamaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwObracunSpecifikacijaPoBankama"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunSpecifikacijaPoBankamaQuery : VwObracunSpecifikacijaPoBankamaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunSpecifikacijaPoBankamaQuery class.
		/// </summary>
		public VwObracunSpecifikacijaPoBankamaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunSpecifikacijaPoBankamaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunSpecifikacijaPoBankamaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunSpecifikacijaPoBankamaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunSpecifikacijaPoBankamaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunSpecifikacijaPoBankamaQuery
		
	#region VwObracunTemeljnicaZaKnjizenjeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwObracunTemeljnicaZaKnjizenje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunTemeljnicaZaKnjizenjeFilters : VwObracunTemeljnicaZaKnjizenjeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunTemeljnicaZaKnjizenjeFilters class.
		/// </summary>
		public VwObracunTemeljnicaZaKnjizenjeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunTemeljnicaZaKnjizenjeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunTemeljnicaZaKnjizenjeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunTemeljnicaZaKnjizenjeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunTemeljnicaZaKnjizenjeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunTemeljnicaZaKnjizenjeFilters
	
	#region VwObracunTemeljnicaZaKnjizenjeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwObracunTemeljnicaZaKnjizenjeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwObracunTemeljnicaZaKnjizenje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunTemeljnicaZaKnjizenjeQuery : VwObracunTemeljnicaZaKnjizenjeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunTemeljnicaZaKnjizenjeQuery class.
		/// </summary>
		public VwObracunTemeljnicaZaKnjizenjeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunTemeljnicaZaKnjizenjeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunTemeljnicaZaKnjizenjeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunTemeljnicaZaKnjizenjeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunTemeljnicaZaKnjizenjeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunTemeljnicaZaKnjizenjeQuery
		
	#region VwObracunTraziFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwObracunTrazi"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunTraziFilters : VwObracunTraziFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunTraziFilters class.
		/// </summary>
		public VwObracunTraziFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunTraziFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunTraziFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunTraziFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunTraziFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunTraziFilters
	
	#region VwObracunTraziQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwObracunTraziParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwObracunTrazi"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunTraziQuery : VwObracunTraziParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunTraziQuery class.
		/// </summary>
		public VwObracunTraziQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunTraziQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunTraziQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunTraziQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunTraziQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunTraziQuery
		
	#region VwObracunVirmaniFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwObracunVirmani"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunVirmaniFilters : VwObracunVirmaniFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunVirmaniFilters class.
		/// </summary>
		public VwObracunVirmaniFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunVirmaniFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunVirmaniFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunVirmaniFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunVirmaniFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunVirmaniFilters
	
	#region VwObracunVirmaniQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwObracunVirmaniParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwObracunVirmani"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunVirmaniQuery : VwObracunVirmaniParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunVirmaniQuery class.
		/// </summary>
		public VwObracunVirmaniQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunVirmaniQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunVirmaniQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunVirmaniQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunVirmaniQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunVirmaniQuery
		
	#region VwObracunZaIDFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwObracunZaID"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunZaIDFilters : VwObracunZaIDFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDFilters class.
		/// </summary>
		public VwObracunZaIDFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunZaIDFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunZaIDFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunZaIDFilters
	
	#region VwObracunZaIDQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwObracunZaIDParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwObracunZaID"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunZaIDQuery : VwObracunZaIDParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDQuery class.
		/// </summary>
		public VwObracunZaIDQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunZaIDQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunZaIDQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunZaIDQuery
		
	#region VwObracunZaIDPoObrascuFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwObracunZaIDPoObrascu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunZaIDPoObrascuFilters : VwObracunZaIDPoObrascuFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPoObrascuFilters class.
		/// </summary>
		public VwObracunZaIDPoObrascuFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPoObrascuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunZaIDPoObrascuFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPoObrascuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunZaIDPoObrascuFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunZaIDPoObrascuFilters
	
	#region VwObracunZaIDPoObrascuQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwObracunZaIDPoObrascuParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwObracunZaIDPoObrascu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunZaIDPoObrascuQuery : VwObracunZaIDPoObrascuParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPoObrascuQuery class.
		/// </summary>
		public VwObracunZaIDPoObrascuQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPoObrascuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunZaIDPoObrascuQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPoObrascuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunZaIDPoObrascuQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunZaIDPoObrascuQuery
		
	#region VwObracunZaIDPorezPrirezFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwObracunZaIDPorezPrirez"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunZaIDPorezPrirezFilters : VwObracunZaIDPorezPrirezFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPorezPrirezFilters class.
		/// </summary>
		public VwObracunZaIDPorezPrirezFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPorezPrirezFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunZaIDPorezPrirezFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPorezPrirezFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunZaIDPorezPrirezFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunZaIDPorezPrirezFilters
	
	#region VwObracunZaIDPorezPrirezQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwObracunZaIDPorezPrirezParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwObracunZaIDPorezPrirez"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunZaIDPorezPrirezQuery : VwObracunZaIDPorezPrirezParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPorezPrirezQuery class.
		/// </summary>
		public VwObracunZaIDPorezPrirezQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPorezPrirezQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunZaIDPorezPrirezQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPorezPrirezQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunZaIDPorezPrirezQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunZaIDPorezPrirezQuery
		
	#region VwObracunZaIDPorezPrirezPoObrascuFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwObracunZaIDPorezPrirezPoObrascu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunZaIDPorezPrirezPoObrascuFilters : VwObracunZaIDPorezPrirezPoObrascuFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPorezPrirezPoObrascuFilters class.
		/// </summary>
		public VwObracunZaIDPorezPrirezPoObrascuFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPorezPrirezPoObrascuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunZaIDPorezPrirezPoObrascuFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPorezPrirezPoObrascuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunZaIDPorezPrirezPoObrascuFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunZaIDPorezPrirezPoObrascuFilters
	
	#region VwObracunZaIDPorezPrirezPoObrascuQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwObracunZaIDPorezPrirezPoObrascuParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwObracunZaIDPorezPrirezPoObrascu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunZaIDPorezPrirezPoObrascuQuery : VwObracunZaIDPorezPrirezPoObrascuParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPorezPrirezPoObrascuQuery class.
		/// </summary>
		public VwObracunZaIDPorezPrirezPoObrascuQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPorezPrirezPoObrascuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunZaIDPorezPrirezPoObrascuQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaIDPorezPrirezPoObrascuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunZaIDPorezPrirezPoObrascuQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunZaIDPorezPrirezPoObrascuQuery
		
	#region VwObracunZaRegosStavkeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwObracunZaRegosStavke"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunZaRegosStavkeFilters : VwObracunZaRegosStavkeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunZaRegosStavkeFilters class.
		/// </summary>
		public VwObracunZaRegosStavkeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaRegosStavkeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunZaRegosStavkeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaRegosStavkeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunZaRegosStavkeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunZaRegosStavkeFilters
	
	#region VwObracunZaRegosStavkeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwObracunZaRegosStavkeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwObracunZaRegosStavke"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwObracunZaRegosStavkeQuery : VwObracunZaRegosStavkeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwObracunZaRegosStavkeQuery class.
		/// </summary>
		public VwObracunZaRegosStavkeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaRegosStavkeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwObracunZaRegosStavkeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwObracunZaRegosStavkeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwObracunZaRegosStavkeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwObracunZaRegosStavkeQuery
		
	#region VwOrganizacijaTVFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwOrganizacijaTV"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwOrganizacijaTVFilters : VwOrganizacijaTVFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwOrganizacijaTVFilters class.
		/// </summary>
		public VwOrganizacijaTVFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwOrganizacijaTVFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwOrganizacijaTVFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwOrganizacijaTVFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwOrganizacijaTVFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwOrganizacijaTVFilters
	
	#region VwOrganizacijaTVQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwOrganizacijaTVParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwOrganizacijaTV"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwOrganizacijaTVQuery : VwOrganizacijaTVParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwOrganizacijaTVQuery class.
		/// </summary>
		public VwOrganizacijaTVQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwOrganizacijaTVQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwOrganizacijaTVQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwOrganizacijaTVQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwOrganizacijaTVQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwOrganizacijaTVQuery
		
	#region VwOsnovnaSredstvaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwOsnovnaSredstva"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwOsnovnaSredstvaFilters : VwOsnovnaSredstvaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwOsnovnaSredstvaFilters class.
		/// </summary>
		public VwOsnovnaSredstvaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwOsnovnaSredstvaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwOsnovnaSredstvaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwOsnovnaSredstvaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwOsnovnaSredstvaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwOsnovnaSredstvaFilters
	
	#region VwOsnovnaSredstvaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwOsnovnaSredstvaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwOsnovnaSredstva"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwOsnovnaSredstvaQuery : VwOsnovnaSredstvaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwOsnovnaSredstvaQuery class.
		/// </summary>
		public VwOsnovnaSredstvaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwOsnovnaSredstvaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwOsnovnaSredstvaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwOsnovnaSredstvaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwOsnovnaSredstvaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwOsnovnaSredstvaQuery
		
	#region VwOsobaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwOsoba"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwOsobaFilters : VwOsobaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwOsobaFilters class.
		/// </summary>
		public VwOsobaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwOsobaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwOsobaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwOsobaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwOsobaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwOsobaFilters
	
	#region VwOsobaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwOsobaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwOsoba"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwOsobaQuery : VwOsobaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwOsobaQuery class.
		/// </summary>
		public VwOsobaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwOsobaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwOsobaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwOsobaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwOsobaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwOsobaQuery
		
	#region VwParametriKorisnikaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwParametriKorisnika"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwParametriKorisnikaFilters : VwParametriKorisnikaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwParametriKorisnikaFilters class.
		/// </summary>
		public VwParametriKorisnikaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwParametriKorisnikaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwParametriKorisnikaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwParametriKorisnikaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwParametriKorisnikaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwParametriKorisnikaFilters
	
	#region VwParametriKorisnikaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwParametriKorisnikaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwParametriKorisnika"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwParametriKorisnikaQuery : VwParametriKorisnikaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwParametriKorisnikaQuery class.
		/// </summary>
		public VwParametriKorisnikaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwParametriKorisnikaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwParametriKorisnikaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwParametriKorisnikaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwParametriKorisnikaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwParametriKorisnikaQuery
		
	#region VwPopisPutnihNalogaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwPopisPutnihNaloga"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwPopisPutnihNalogaFilters : VwPopisPutnihNalogaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwPopisPutnihNalogaFilters class.
		/// </summary>
		public VwPopisPutnihNalogaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwPopisPutnihNalogaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwPopisPutnihNalogaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwPopisPutnihNalogaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwPopisPutnihNalogaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwPopisPutnihNalogaFilters
	
	#region VwPopisPutnihNalogaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwPopisPutnihNalogaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwPopisPutnihNaloga"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwPopisPutnihNalogaQuery : VwPopisPutnihNalogaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwPopisPutnihNalogaQuery class.
		/// </summary>
		public VwPopisPutnihNalogaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwPopisPutnihNalogaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwPopisPutnihNalogaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwPopisPutnihNalogaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwPopisPutnihNalogaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwPopisPutnihNalogaQuery
		
	#region VwPreostaloZaZatvaranjeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwPreostaloZaZatvaranje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwPreostaloZaZatvaranjeFilters : VwPreostaloZaZatvaranjeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeFilters class.
		/// </summary>
		public VwPreostaloZaZatvaranjeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwPreostaloZaZatvaranjeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwPreostaloZaZatvaranjeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwPreostaloZaZatvaranjeFilters
	
	#region VwPreostaloZaZatvaranjeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwPreostaloZaZatvaranjeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwPreostaloZaZatvaranje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwPreostaloZaZatvaranjeQuery : VwPreostaloZaZatvaranjeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeQuery class.
		/// </summary>
		public VwPreostaloZaZatvaranjeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwPreostaloZaZatvaranjeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwPreostaloZaZatvaranjeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwPreostaloZaZatvaranjeQuery
		
	#region VwPreostaloZaZatvaranjeZapisanoSimpleFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwPreostaloZaZatvaranjeZapisanoSimple"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwPreostaloZaZatvaranjeZapisanoSimpleFilters : VwPreostaloZaZatvaranjeZapisanoSimpleFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeZapisanoSimpleFilters class.
		/// </summary>
		public VwPreostaloZaZatvaranjeZapisanoSimpleFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeZapisanoSimpleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwPreostaloZaZatvaranjeZapisanoSimpleFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeZapisanoSimpleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwPreostaloZaZatvaranjeZapisanoSimpleFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwPreostaloZaZatvaranjeZapisanoSimpleFilters
	
	#region VwPreostaloZaZatvaranjeZapisanoSimpleQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwPreostaloZaZatvaranjeZapisanoSimpleParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwPreostaloZaZatvaranjeZapisanoSimple"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwPreostaloZaZatvaranjeZapisanoSimpleQuery : VwPreostaloZaZatvaranjeZapisanoSimpleParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeZapisanoSimpleQuery class.
		/// </summary>
		public VwPreostaloZaZatvaranjeZapisanoSimpleQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeZapisanoSimpleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwPreostaloZaZatvaranjeZapisanoSimpleQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeZapisanoSimpleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwPreostaloZaZatvaranjeZapisanoSimpleQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwPreostaloZaZatvaranjeZapisanoSimpleQuery
		
	#region VwPreostaloZaZatvaranjeZapisanoSimpleSviFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwPreostaloZaZatvaranjeZapisanoSimpleSvi"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwPreostaloZaZatvaranjeZapisanoSimpleSviFilters : VwPreostaloZaZatvaranjeZapisanoSimpleSviFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeZapisanoSimpleSviFilters class.
		/// </summary>
		public VwPreostaloZaZatvaranjeZapisanoSimpleSviFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeZapisanoSimpleSviFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwPreostaloZaZatvaranjeZapisanoSimpleSviFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeZapisanoSimpleSviFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwPreostaloZaZatvaranjeZapisanoSimpleSviFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwPreostaloZaZatvaranjeZapisanoSimpleSviFilters
	
	#region VwPreostaloZaZatvaranjeZapisanoSimpleSviQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwPreostaloZaZatvaranjeZapisanoSimpleSviParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwPreostaloZaZatvaranjeZapisanoSimpleSvi"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwPreostaloZaZatvaranjeZapisanoSimpleSviQuery : VwPreostaloZaZatvaranjeZapisanoSimpleSviParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeZapisanoSimpleSviQuery class.
		/// </summary>
		public VwPreostaloZaZatvaranjeZapisanoSimpleSviQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeZapisanoSimpleSviQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwPreostaloZaZatvaranjeZapisanoSimpleSviQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwPreostaloZaZatvaranjeZapisanoSimpleSviQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwPreostaloZaZatvaranjeZapisanoSimpleSviQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwPreostaloZaZatvaranjeZapisanoSimpleSviQuery
		
	#region VwPrijenosRadnogNalogaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwPrijenosRadnogNaloga"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwPrijenosRadnogNalogaFilters : VwPrijenosRadnogNalogaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwPrijenosRadnogNalogaFilters class.
		/// </summary>
		public VwPrijenosRadnogNalogaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwPrijenosRadnogNalogaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwPrijenosRadnogNalogaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwPrijenosRadnogNalogaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwPrijenosRadnogNalogaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwPrijenosRadnogNalogaFilters
	
	#region VwPrijenosRadnogNalogaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwPrijenosRadnogNalogaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwPrijenosRadnogNaloga"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwPrijenosRadnogNalogaQuery : VwPrijenosRadnogNalogaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwPrijenosRadnogNalogaQuery class.
		/// </summary>
		public VwPrijenosRadnogNalogaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwPrijenosRadnogNalogaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwPrijenosRadnogNalogaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwPrijenosRadnogNalogaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwPrijenosRadnogNalogaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwPrijenosRadnogNalogaQuery
		
	#region VwRabatFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwRabat"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwRabatFilters : VwRabatFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwRabatFilters class.
		/// </summary>
		public VwRabatFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwRabatFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwRabatFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwRabatFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwRabatFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwRabatFilters
	
	#region VwRabatQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwRabatParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwRabat"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwRabatQuery : VwRabatParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwRabatQuery class.
		/// </summary>
		public VwRabatQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwRabatQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwRabatQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwRabatQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwRabatQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwRabatQuery
		
	#region VwRadniNalogVezeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwRadniNalogVeze"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwRadniNalogVezeFilters : VwRadniNalogVezeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwRadniNalogVezeFilters class.
		/// </summary>
		public VwRadniNalogVezeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwRadniNalogVezeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwRadniNalogVezeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwRadniNalogVezeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwRadniNalogVezeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwRadniNalogVezeFilters
	
	#region VwRadniNalogVezeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwRadniNalogVezeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwRadniNalogVeze"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwRadniNalogVezeQuery : VwRadniNalogVezeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwRadniNalogVezeQuery class.
		/// </summary>
		public VwRadniNalogVezeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwRadniNalogVezeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwRadniNalogVezeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwRadniNalogVezeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwRadniNalogVezeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwRadniNalogVezeQuery
		
	#region VwReportFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwReport"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwReportFilters : VwReportFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwReportFilters class.
		/// </summary>
		public VwReportFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwReportFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwReportFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwReportFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwReportFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwReportFilters
	
	#region VwReportQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwReportParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwReport"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwReportQuery : VwReportParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwReportQuery class.
		/// </summary>
		public VwReportQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwReportQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwReportQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwReportQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwReportQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwReportQuery
		
	#region VwSKPoDokumentimaPoTipuFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwSKPoDokumentimaPoTipu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwSKPoDokumentimaPoTipuFilters : VwSKPoDokumentimaPoTipuFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwSKPoDokumentimaPoTipuFilters class.
		/// </summary>
		public VwSKPoDokumentimaPoTipuFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwSKPoDokumentimaPoTipuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwSKPoDokumentimaPoTipuFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwSKPoDokumentimaPoTipuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwSKPoDokumentimaPoTipuFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwSKPoDokumentimaPoTipuFilters
	
	#region VwSKPoDokumentimaPoTipuQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwSKPoDokumentimaPoTipuParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwSKPoDokumentimaPoTipu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwSKPoDokumentimaPoTipuQuery : VwSKPoDokumentimaPoTipuParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwSKPoDokumentimaPoTipuQuery class.
		/// </summary>
		public VwSKPoDokumentimaPoTipuQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwSKPoDokumentimaPoTipuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwSKPoDokumentimaPoTipuQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwSKPoDokumentimaPoTipuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwSKPoDokumentimaPoTipuQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwSKPoDokumentimaPoTipuQuery
		
	#region VwTmpSaldoKlijentaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwTmpSaldoKlijenta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwTmpSaldoKlijentaFilters : VwTmpSaldoKlijentaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwTmpSaldoKlijentaFilters class.
		/// </summary>
		public VwTmpSaldoKlijentaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwTmpSaldoKlijentaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwTmpSaldoKlijentaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwTmpSaldoKlijentaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwTmpSaldoKlijentaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwTmpSaldoKlijentaFilters
	
	#region VwTmpSaldoKlijentaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwTmpSaldoKlijentaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwTmpSaldoKlijenta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwTmpSaldoKlijentaQuery : VwTmpSaldoKlijentaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwTmpSaldoKlijentaQuery class.
		/// </summary>
		public VwTmpSaldoKlijentaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwTmpSaldoKlijentaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwTmpSaldoKlijentaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwTmpSaldoKlijentaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwTmpSaldoKlijentaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwTmpSaldoKlijentaQuery
		
	#region VwVezeDokumentaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwVezeDokumenta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwVezeDokumentaFilters : VwVezeDokumentaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwVezeDokumentaFilters class.
		/// </summary>
		public VwVezeDokumentaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwVezeDokumentaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwVezeDokumentaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwVezeDokumentaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwVezeDokumentaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwVezeDokumentaFilters
	
	#region VwVezeDokumentaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwVezeDokumentaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwVezeDokumenta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwVezeDokumentaQuery : VwVezeDokumentaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwVezeDokumentaQuery class.
		/// </summary>
		public VwVezeDokumentaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwVezeDokumentaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwVezeDokumentaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwVezeDokumentaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwVezeDokumentaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwVezeDokumentaQuery
		
	#region VwVirmanOdabirFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VwVirmanOdabir"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwVirmanOdabirFilters : VwVirmanOdabirFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwVirmanOdabirFilters class.
		/// </summary>
		public VwVirmanOdabirFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwVirmanOdabirFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwVirmanOdabirFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwVirmanOdabirFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwVirmanOdabirFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwVirmanOdabirFilters
	
	#region VwVirmanOdabirQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VwVirmanOdabirParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VwVirmanOdabir"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VwVirmanOdabirQuery : VwVirmanOdabirParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VwVirmanOdabirQuery class.
		/// </summary>
		public VwVirmanOdabirQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VwVirmanOdabirQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VwVirmanOdabirQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VwVirmanOdabirQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VwVirmanOdabirQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VwVirmanOdabirQuery
	#endregion

	
}
